@xhulz/nina 0.46.0 → 0.48.0

package/src/commands/init.mjs

@@ -21,7 +21,7 @@ import { join, resolve } from 'node:path';
 import { REQUIRES, SLOT, byVersion, closedGate, composedPaths, composeProject, defaultedSlots, layerRootFor, projectOwned, walk } from './compose.mjs';
 import { owedDocuments } from './check.mjs';
 import { PLACEHOLDER, defaultVocabulary } from '../vocabulary.mjs';
-import { DETECTABLE, NEEDS } from '../surfaces.mjs';
+import { DETECTABLE, missingNeeds } from '../surfaces.mjs';
 import { bold, dim, green, pink } from '../look.mjs';
 
 /**
@@ -35,11 +35,13 @@ const QUESTIONS = {
   'external-api': 'Does it depend on anything whose behavior it does not define?',
   db: 'Does it own persistent data of its own?',
   prisma: 'Does it reach that data through Prisma?',
+  drizzle: 'Does it reach that data through Drizzle?',
   money: 'Does it conserve and distribute an amount — money in equals money out plus retained?',
   pii: 'Does it hold data about people that would harm someone specific if it leaked?',
   integrations: 'Does it depend on anything whose behavior it does not define?',
   frontend: 'Does it render a screen a person looks at?',
   'edge-cf': 'Does it run on Cloudflare Workers or Pages?',
+  d1: 'Does it keep that data in Cloudflare D1?',
   // Not "does it use blockchain" — that is a technology, and a technology is not a reason to
   // gate anything. What this surface costs is immutability: code that ships cannot be edited.
   blockchain: 'Does it deploy code that cannot be changed once it is live?',
@@ -59,7 +61,7 @@ function questionFor(surface) {
  * The order the interview asks in: the surfaces most projects have first, the rare ones last. Asked
  * alphabetically, the first question a web app met was whether it deploys immutable code.
  */
-const ASK_ORDER = ['db', 'prisma', 'frontend', 'integrations', 'pii', 'money', 'edge-cf', 'blockchain'];
+const ASK_ORDER = ['db', 'prisma', 'drizzle', 'frontend', 'integrations', 'pii', 'money', 'edge-cf', 'd1', 'blockchain'];
 
 /**
  * The surfaces a core offers, in the order the interview asks them; one it does not know goes last.
@@ -216,14 +218,21 @@ async function interview(available, matched, impacts) {
     const scope = lines.join(' ');
 
     const order = available;
-    console.log(`\n  ${strong('Surfaces')} — ${order.length} yes-or-no questions, one per surface.`);
+    console.log(`\n  ${strong('Surfaces')} — up to ${order.length} yes-or-no questions, one per surface; a stack comes only after a yes to what it needs.`);
     console.log('  A surface is a part of the harness only some projects need: its rules, its checks, sometimes a');
     console.log('  whole role. Answer for what the project does today; one can be added later in .nina/profile.json.\n');
     const surfaces = [];
+    let asked = 0;
     for (const [n, s] of order.entries()) {
       // A stack is asked about only where its concern was answered yes: asked whether data it does not
       // own goes through Prisma, a project has nothing true to answer.
-      if (NEEDS[s] && !surfaces.includes(NEEDS[s])) continue;
+      if (missingNeeds(s, surfaces).length > 0) continue;
+      // Counted by what is asked, not by place in the list: numbered by place, a no to the database read
+      // 1/10 then 4/10, and the header promised ten questions to someone asked seven. The total is what is
+      // asked so far plus what can still be, so a no shrinks it; the last question is n/n while the order
+      // ends with a surface that needs nothing, as it does.
+      asked += 1;
+      const total = asked + order.slice(n + 1).filter((t) => missingNeeds(t, [...surfaces, ...order.slice(n)]).length === 0).length;
       const i = impacts[s];
       const reason = matched.find((d) => d.surface === s)?.why;
       // What a yes brings, in what a person would recognise: roles, rules, agents. The count of
@@ -233,7 +242,7 @@ async function interview(available, matched, impacts) {
         ...(i.rules ? [`${i.rules} hard rule${i.rules > 1 ? 's' : ''}`] : []),
         ...(i.agents.length ? [`changes to ${i.agents.length} agent${i.agents.length > 1 ? 's' : ''}`] : []),
       ];
-      console.log(`  ${faint(`${n + 1}/${order.length}`)}  ${strong(s)}`);
+      console.log(`  ${faint(`${asked}/${total}`)}  ${strong(s)}`);
       console.log(`       ${questionFor(s)}`);
       console.log(faint(`       if yes: ${brings.length ? brings.join(' · ') : `guidance in ${i.fragments} places`}`));
       if (reason) console.log(found(`       already here: ${reason}`));

package/src/commands/upgrade.mjs

@@ -15,7 +15,7 @@ import { describeMove, HARNESS, interruptedMove, movedFrom, moveJournal, readPro
 import { existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { REMOVED, composeProject, composedPaths, defaultedSlots, layerRootFor, walk } from './compose.mjs';
-import { NEEDS, detected } from '../surfaces.mjs';
+import { detected, missingNeeds } from '../surfaces.mjs';
 import { filledSlots, projectSlots, referencedVocabulary } from './check.mjs';
 import { EXPECT_ENV } from '../expected.mjs';
 import { closeAnswered } from './learn.mjs';
@@ -297,7 +297,7 @@ export async function upgrade(argv, ctx) {
   // them in silence: the rules that were in its specs yesterday are not there after the move.
   const offeredBefore = (await surfacesIn(from.dir));
   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])),
+    (d) => available.includes(d.surface) && !offeredBefore.includes(d.surface) && !surfaces.includes(d.surface) && missingNeeds(d.surface, kept).length === 0,
   );
 
   const [vocabBefore, vocabAfter] = [

package/src/gate.mjs

@@ -280,11 +280,13 @@ function append(path, entry) {
  * @param {object[]} entries - The ledger, oldest first.
  * @param {ReturnType<typeof loopEdges>} loops - The capped loop-back edges.
  * @param {Map<string, Set<string>>} [forward] - Stage → the sources that hand passing work on to it.
- * @returns {{effect: (to: string) => {rounds: object[]}, rounds: object[]}}
+ * @returns {{effect: (to: string) => {rounds: object[]}, rounds: object[], open: object[], waiting: object[]}}
  *   A round is `{source, target, token, round, max, edgeRound, ceiling, agents}`, plus `issue` (the id
  *   that decides it) and `issues` (every id with its count) when it was counted by issue.
  *   `effect` says what a dispatch to a stage would make now, without making it; `rounds` is every round
- *   the recorded dispatches made.
+ *   the recorded dispatches made; `open` each loop still counted, with whether a pass already closes it
+ *   (`closing`), the stages a dispatch to which would (`targets`) and the stages whose pass would (`onward`);
+ *   `waiting` each loop-back no fix has acted on yet.
  */
 export function replay(entries, loops, forward = new Map()) {
   // When each dispatch went out. A foreground dispatch's `dispatch` entry is written after the agent
@@ -329,15 +331,23 @@ export function replay(entries, loops, forward = new Map()) {
     for (const map of [streak, grace]) for (const key of [...map.keys()]) if (key.startsWith(`${source}|`)) map.delete(key);
   };
 
+  /**
+   * A source's waiting verdicts, settled: the rejections no later review of a fix cancelled, and whether a pass
+   * closes its loops — one that began after the latest fix, with no rejection running beside it.
+   */
+  const settle = (source, batch) => {
+    const passes = batch.filter((v) => !isLoopBack(v.verdict));
+    const live = batch.filter((v) => isLoopBack(v.verdict) && !passes.some((p) => p.launch > v.at && fixBetween(source, v.at, p.launch)));
+    return { live, closes: passes.some((p) => p.launch > (lastFix.get(source) ?? -1) && !live.some((v) => v.launch < p.at)) };
+  };
+
   const effect = (to, at) => {
     const rounds = [];
     const outcome = [];
     for (const [source, batch] of pending) {
       const byToken = loops.get(source);
       if (!byToken || batch.length === 0 || !targetsOf(source).has(to)) continue;
-      const passes = batch.filter((v) => !isLoopBack(v.verdict));
-      const live = batch.filter((v) => isLoopBack(v.verdict) && !passes.some((p) => p.launch > v.at && fixBetween(source, v.at, p.launch)));
-      const closes = passes.some((p) => p.launch > (lastFix.get(source) ?? -1) && !live.some((v) => v.launch < p.at));
+      const { live, closes } = settle(source, batch);
       const routed = live.filter((v) => byToken.get(v.verdict)?.has(to));
       const fresh = routed.filter((v) => {
         const last = streak.get(`${source}|${v.verdict}`);
@@ -434,13 +444,18 @@ export function replay(entries, loops, forward = new Map()) {
   });
   // What is open when the replay ends: each loop with its rounds, the rounds the owner's replies gave it and the
   // issues it counted by, and each loop-back no fix has acted on yet — what a compaction takes from the orchestrator.
+  // A loop whose source passed after the latest fix is closed by the next dispatch it could act on, and until then
+  // is still in the count; it says so, and what would close each of the others. Listed as open, three loops
+  // approved the evening before a compaction were handed back as capped, and the orchestrator went looking for why.
   const open = [...streak.entries()]
     .filter(([key]) => key.split('|').length === 2)
     .map(([key, s]) => {
       const [source, token] = key.split('|');
       const cap = Math.max(0, ...(loops.get(source)?.get(token)?.values() ?? []));
       const issues = [...streak.keys()].filter((k) => k.startsWith(`${key}|`)).map((k) => k.slice(key.length + 1));
-      return { source, token, rounds: s.n, cap, given: grace.get(key) ?? 0, issues };
+      const closing = settle(source, pending.get(source) ?? []).closes;
+      const onward = [...forward].filter(([, sources]) => sources.has(source)).map(([stage]) => stage);
+      return { source, token, rounds: s.n, cap, given: grace.get(key) ?? 0, issues, closing, targets: [...targetsOf(source)], onward };
     });
   const waiting = [...pending.entries()].flatMap(([source, batch]) => batch.filter((v) => isLoopBack(v.verdict)).map((v) => ({ source, verdict: v.verdict, issues: v.issues ?? [] })));
   return { effect: (to) => effect(to, entries.length), rounds: made, open, waiting };
@@ -671,32 +686,56 @@ function onPre(input, project, path, at) {
   return confirmation(worst);
 }
 
+/** Stages as a sentence lists them: `qa`, `implementer or architect`, `a, b or c`. */
+const either = (stages) => (stages.length < 2 ? stages.join('') : `${stages.slice(0, -1).join(', ')} or ${stages.at(-1)}`);
+
 /**
- * What the gate hands the orchestrator after its conversation was compacted: the loops still open and the
- * loop-backs waiting on a fix, the latest dispatches, where the checkout stands, and the two documents to read
- * again. The graph and the router are read once, at a session's start, and a compaction drops them with every
- * report; the router told the orchestrator to write "round 2 of max 2" in a dispatch so "you after a
- * compaction" could see it, and after a compaction it sees only a summary.
+ * What a session's ledger says of its loops, a line each: every loop still counted, and what would close it;
+ * the loop-backs no fix has acted on yet; and the latest dispatches. It is what a compaction hands the
+ * orchestrator and what `nina gate --status` prints, so the two cannot disagree.
  *
  * @param {object} project - `loadProject`'s.
- * @param {string} path - The session's ledger.
- * @param {string} root - The project.
- * @returns {object}
+ * @param {object[]} entries - The session's ledger, oldest first.
+ * @returns {{lines: string[], open: number, closing: number, waiting: number}} The lines; the loops open, the
+ *   loops a pass already settled, whose count the next dispatch drops, and the loop-backs waiting on a fix.
  */
-function afterCompaction(project, path, root) {
-  const entries = readLedger(path);
+export function loopState(project, entries) {
   const { open, waiting } = replay(entries, project.loops, project.forward);
-  const lines = ['The conversation was compacted. What the NINA loop gate kept of this session:'];
+  const lines = [];
   for (const l of open) {
+    const count =
+      `${l.source} ${l.token} — ${l.rounds} round(s), capped at ${l.cap}${l.given ? ` and ${l.given} more from the owner's replies` : ''}` +
+      (l.issues.length ? `, issues ${l.issues.join(', ')}` : '');
+    const fix = waiting.some((w) => w.source === l.source) ? 'the fix it waits on' : 'the latest fix';
     lines.push(
-      `- open loop: ${l.source} ${l.token} — ${l.rounds} round(s), capped at ${l.cap}${l.given ? ` and ${l.given} more from the owner's replies` : ''}` +
-        (l.issues.length ? `, issues ${l.issues.join(', ')}` : ''),
+      l.closing
+        ? `- passed after its latest fix: ${count}. Those rounds are settled, and the gate drops them at the next dispatch to ${either(l.targets)}`
+        : `- open loop: ${count}. It closes when a ${l.source} launched after ${fix} passes with no rejection beside it` +
+            (l.onward.length ? `, or when ${either(l.onward)} passes, sent out after the ${l.source} last reported` : ''),
     );
   }
   for (const w of waiting) lines.push(`- waiting on a fix: ${w.source} ${w.verdict}${w.issues.length ? `, issues ${w.issues.join(', ')}` : ''}`);
   if (open.length === 0 && waiting.length === 0) lines.push('- no loop is open');
   const dispatched = entries.filter((e) => e.k === 'dispatch' && e.role).slice(-4);
   if (dispatched.length) lines.push(`- the latest dispatches: ${dispatched.map((e) => e.role).join(', ')}, the newest at ${String(dispatched.at(-1).at ?? '').slice(11, 16)} UTC`);
+  const closing = open.filter((l) => l.closing).length;
+  return { lines, open: open.length - closing, closing, waiting: waiting.length };
+}
+
+/**
+ * What the gate hands the orchestrator after its conversation was compacted: the loops still open and the
+ * loop-backs waiting on a fix, the latest dispatches, where the checkout stands, and the two documents to read
+ * again. The graph and the router are read once, at a session's start, and a compaction drops them with every
+ * report; the router told the orchestrator to write "round 2 of max 2" in a dispatch so "you after a
+ * compaction" could see it, and after a compaction it sees only a summary.
+ *
+ * @param {object} project - `loadProject`'s.
+ * @param {string} path - The session's ledger.
+ * @param {string} root - The project.
+ * @returns {object}
+ */
+function afterCompaction(project, path, root) {
+  const lines = ['The conversation was compacted. What the NINA loop gate kept of this session:', ...loopState(project, readLedger(path)).lines];
   const git = (...args) => spawnSync('git', ['-C', root, ...args], { encoding: 'utf8', timeout: 2000 }).stdout?.trim() ?? '';
   const branch = git('rev-parse', '--abbrev-ref', 'HEAD');
   const last = git('log', '-1', '--format=%h %s');

package/src/surfaces.mjs

@@ -12,17 +12,33 @@
  * `init`, `check` and `upgrade` all read this, so a surface's evidence and its prerequisite are stated once.
  */
 
+/** A drizzle-kit config, which a Drizzle project usually has and nothing else names so. */
+const DRIZZLE_CONFIG = /(^|\/)drizzle\.config\.[cm]?[jt]s$/;
+
 /** 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: 'db', why: 'a Prisma schema or a drizzle-kit config', test: (f) => f.some((p) => p.endsWith('schema.prisma') || DRIZZLE_CONFIG.test(p)) },
   { surface: 'prisma', why: 'a Prisma schema', test: (f) => f.some((p) => p.endsWith('schema.prisma')) },
+  { surface: 'drizzle', why: 'a drizzle-kit config', test: (f) => f.some((p) => DRIZZLE_CONFIG.test(p)) },
   { 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' };
+/**
+ * A stack surface, and every surface it is a stack of: declared without one of them, its rules have nowhere
+ * to land. Most stacks need one concern; an engine that only runs on one platform needs the platform too.
+ */
+export const NEEDS = { prisma: ['db'], drizzle: ['db'], d1: ['db', 'edge-cf'] };
+
+/**
+ * What a stack needs that a profile does not declare — empty for a surface that is not a stack.
+ *
+ * @param {string} surface - The surface asked about.
+ * @param {string[]} declared - The surfaces declared, or answered yes so far.
+ * @returns {string[]}
+ */
+export const missingNeeds = (surface, declared) => (NEEDS[surface] ?? []).filter((need) => !declared.includes(need));
 
 /**
  * The surfaces a project's files reveal, with the evidence for each.