arkgate 2.8.1 → 2.8.3

package/bin/lib/core-ratchet.mjs

@@ -0,0 +1,152 @@
+/**
+ * Core-layer optionality ratchet — pure plan + CLI runner.
+ * Keeps ark-check.mjs orchestration-only (dispatch only).
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { arkCommand } from '../ark-shared.mjs';
+import { computeCoverage } from './doctor-plan.mjs';
+
+/**
+ * Core layers whose optionality matters once they match files (presets share these names).
+ * Used by doctor adoption gaps and `--ratchet-cores`.
+ */
+export const CORE_LAYER_NAMES = new Set([
+  'DomainModel',
+  'ApplicationOrchestration',
+  'PresentationAdapters',
+  'PersistenceAdapters',
+]);
+
+/**
+ * Plan a ratchet of optional→required for core layers that already match files.
+ * Empty cores stay optional (avoids false ENFORCE theatre). Pure — does not write disk.
+ *
+ * @param {object} config ark.config.json shape
+ * @param {{ name: string, files: number }[]} layerRows coverage layer rows
+ */
+export function planPopulatedCoreRatchet(config, layerRows = []) {
+  const countByName = new Map(
+    (Array.isArray(layerRows) ? layerRows : []).map((row) => [row.name, Number(row.files) || 0])
+  );
+  const ratcheted = [];
+  const alreadyStrict = [];
+  const stillOptionalEmpty = [];
+  const nextLayers = (config?.layers ?? []).map((layer) => {
+    if (!CORE_LAYER_NAMES.has(layer.name)) return layer;
+    const files = countByName.get(layer.name) ?? 0;
+    if (layer.optional !== true) {
+      if (files > 0) alreadyStrict.push({ layer: layer.name, files });
+      return layer;
+    }
+    if (files <= 0) {
+      stillOptionalEmpty.push(layer.name);
+      return layer;
+    }
+    ratcheted.push({ layer: layer.name, files });
+    return { ...layer, optional: false };
+  });
+  return {
+    ratcheted,
+    alreadyStrict,
+    stillOptionalEmpty,
+    config: { ...(config ?? {}), layers: nextLayers },
+    changed: ratcheted.length > 0,
+  };
+}
+
+/**
+ * When the architecture is green (raw violations = 0, not baselined), ratchet populated
+ * core layers from optional→required so doctor can honestly report ENFORCE.
+ * Empty cores stay optional. Always writes when changes apply (like --update-baseline).
+ *
+ * @param {string} root
+ * @param {object} config
+ * @param {string[]} files
+ * @param {object[]} rules
+ * @param {object[]} violations raw scan violations (baseline ignored — must be truly clean)
+ * @param {{ json?: boolean, config?: string }} args
+ * @param {{ displayPathFromRoot: (root: string, abs: string) => string }} deps
+ */
+export function runRatchetCores(root, config, files, rules, violations, args, deps) {
+  const displayPathFromRoot = deps.displayPathFromRoot;
+  const cov = computeCoverage(root, config, files, rules);
+  const activeCount = Array.isArray(violations) ? violations.length : 0;
+  const configPath = path.isAbsolute(args.config)
+    ? args.config
+    : path.join(root, args.config || 'ark.config.json');
+
+  const refuse = (code, message, extra = {}) => {
+    if (args.json) {
+      console.log(JSON.stringify({ ok: false, error: message, ...extra }, null, 2));
+    } else {
+      console.error(message);
+    }
+    process.exitCode = code;
+  };
+
+  if (activeCount > 0) {
+    refuse(
+      2,
+      `Refusing --ratchet-cores: ${activeCount} active architecture violation(s) (raw graph; baseline does not count). Resolve them first (ark-check --plan), then re-run.`,
+      { activeViolations: activeCount, governed: cov.governed }
+    );
+    return;
+  }
+  if (cov.totalFiles === 0 || (cov.governed?.percent ?? 0) < 50) {
+    refuse(
+      2,
+      `Refusing --ratchet-cores: governed coverage is too low (${cov.governed?.percent ?? 0}% of ${cov.totalFiles} files). Classify ungoverned code first.`,
+      { governed: cov.governed }
+    );
+    return;
+  }
+
+  const plan = planPopulatedCoreRatchet(config, cov.layers);
+  if (!plan.changed) {
+    const payload = {
+      ok: true,
+      changed: false,
+      message: 'No optional core layers with files — nothing to ratchet.',
+      alreadyStrict: plan.alreadyStrict,
+      stillOptionalEmpty: plan.stillOptionalEmpty,
+      governed: cov.governed,
+    };
+    if (args.json) console.log(JSON.stringify(payload, null, 2));
+    else {
+      console.log(payload.message);
+      if (plan.stillOptionalEmpty.length > 0) {
+        console.log(`Still optional (empty patterns): ${plan.stillOptionalEmpty.join(', ')}`);
+      }
+    }
+    return;
+  }
+
+  fs.writeFileSync(configPath, `${JSON.stringify(plan.config, null, 2)}\n`);
+  const payload = {
+    ok: true,
+    changed: true,
+    configPath: displayPathFromRoot(root, configPath),
+    ratcheted: plan.ratcheted,
+    stillOptionalEmpty: plan.stillOptionalEmpty,
+    governed: cov.governed,
+    next: arkCommand(root, 'ark-check', '--doctor'),
+  };
+  if (args.json) {
+    console.log(JSON.stringify(payload, null, 2));
+  } else {
+    console.log(
+      `Ratcheted ${plan.ratcheted.length} core layer(s) to optional: false (populated only):`
+    );
+    for (const row of plan.ratcheted) {
+      console.log(`  ${row.layer} (${row.files} file(s))`);
+    }
+    if (plan.stillOptionalEmpty.length > 0) {
+      console.log(
+        `Left optional (empty patterns — avoid false ENFORCE): ${plan.stillOptionalEmpty.join(', ')}`
+      );
+    }
+    console.log(`Wrote ${displayPathFromRoot(root, configPath)}`);
+    console.log(`Confirm: ${payload.next}`);
+  }
+}

package/bin/lib/doctor-plan.mjs

@@ -290,6 +290,15 @@ export function runDoctor(root, config, files, rules, violations, asJson, option
               governedPercent: cov.governed.percent,
               planMet: activeCount === 0 && cov.governed.percent >= 50,
               mature: cov.governed.totalFiles >= 150,
+              totalFiles: cov.governed.totalFiles,
+              emptyLayers: cov.emptyLayers,
+              coreOptionalWithFiles: adoption.coreOptional?.length ?? 0,
+              presentationShare: (() => {
+                const total = cov.governed.totalFiles || 0;
+                if (total <= 0) return null;
+                const p = cov.layers.find((r) => r.name === 'PresentationAdapters');
+                return p ? p.files / total : null;
+              })(),
             }),
             governed: cov.governed,
             emptyLayers: cov.emptyLayers,
@@ -345,11 +354,18 @@ export function runDoctor(root, config, files, rules, violations, asJson, option
   console.log(color.bold(`Ark doctor — ${path.basename(path.resolve(root)) || '.'}`));
 
   const emptyScope = cov.governed.totalFiles === 0;
+  const totalFiles = cov.governed.totalFiles || 0;
+  const presentationRow = cov.layers.find((r) => r.name === 'PresentationAdapters');
   const mode = resolveOperatingMode({
     governedPercent: emptyScope ? 0 : cov.governed.percent,
     planMet:
       activeCount === 0 && !emptyScope && cov.governed.percent >= 50,
     mature: cov.governed.totalFiles >= 150,
+    totalFiles: cov.governed.totalFiles,
+    emptyLayers: cov.emptyLayers,
+    coreOptionalWithFiles: adoption.coreOptional?.length ?? 0,
+    presentationShare:
+      totalFiles > 0 && presentationRow ? presentationRow.files / totalFiles : null,
   });
   console.log('');
   console.log(color.bold('Operating mode'));

package/bin/lib/html-report.mjs

@@ -153,6 +153,17 @@ export function computeReportFitness({ coverage, violations, ok, enforcement, co
   const governedPercent = coverage?.governed?.percent ?? null;
   const totalFiles = coverage?.governed?.totalFiles ?? 0;
   const classifiedFiles = coverage?.governed?.classifiedFiles ?? 0;
+  const emptyLayers = (coverage?.layers ?? [])
+    .filter((r) => (r.files ?? 0) === 0)
+    .map((r) => r.name);
+  const presentationRow = (coverage?.layers ?? []).find(
+    (r) => r.name === 'PresentationAdapters'
+  );
+  const coreOptionalWithFiles = (config?.layers ?? []).filter((layer) => {
+    if (layer.optional !== true) return false;
+    const row = (coverage?.layers ?? []).find((r) => r.name === layer.name);
+    return (row?.files ?? 0) > 0;
+  }).length;
   const mode = resolveOperatingMode({
     governedPercent: totalFiles === 0 ? 0 : governedPercent,
     planMet:
@@ -162,6 +173,10 @@ export function computeReportFitness({ coverage, violations, ok, enforcement, co
       (governedPercent == null || governedPercent >= 50),
     mature: totalFiles >= 150,
     totalFiles,
+    emptyLayers,
+    coreOptionalWithFiles,
+    presentationShare:
+      totalFiles > 0 && presentationRow ? presentationRow.files / totalFiles : null,
   });
   const modeLabel = { suggest: 'SUGGEST', adapt: 'ADAPT', enforce: 'ENFORCE' }[mode] || String(mode).toUpperCase();
   const modeBlurb = {

package/bin/lib/presets.mjs

@@ -267,22 +267,29 @@ export const ARCHITECTURE_PRESETS = {
             name: 'DomainModel',
             description: 'Shared types and pure view-models (optional on UI-first trees).',
             // Avoid bare **/types.ts — see monorepo DomainModel note (false Domain on core/**/types.ts).
-            patterns: ['**/domain/**', '**/cinematic/types.ts'],
+            patterns: [
+              '**/domain/**',
+              '**/cinematic/types.ts',
+              // Common pure types bag (not **/types.ts — that traps core/**/types.ts).
+              'src/lib/types.ts',
+            ],
             exclude: FRAMEWORK_INTERNAL_EXCLUDE,
             forbiddenGlobals: DEFAULT_DOMAIN_FORBIDDEN_GLOBALS,
             optional: true,
           },
           {
-            name: 'PresentationAdapters',
-            description: 'UI, routes, hooks, components, compositions.',
+            name: 'ApplicationOrchestration',
+            description: 'Server actions, features, and non-UI lib orchestration (when present).',
             patterns: [
-              '**/src/**',
-              '**/components/**',
-              '**/hooks/**',
-              '**/lib/**',
-              '**/routes/**',
-              '**/app/**',
-              '**/pages/**',
+              'src/features/**',
+              'src/server/**',
+              'src/services/**',
+              'src/use-cases/**',
+              'src/actions/**',
+              'src/lib/actions/**',
+              'src/lib/services/**',
+              '**/lib/actions/**',
+              '**/lib/services/**',
             ],
             exclude: FRAMEWORK_INTERNAL_EXCLUDE,
             optional: true,
@@ -290,7 +297,61 @@ export const ARCHITECTURE_PRESETS = {
           {
             name: 'PersistenceAdapters',
             description: 'Client data access and external API adapters (when present).',
-            patterns: ['**/infrastructure/**', '**/adapters/**', '**/repositories/**'],
+            // Prefer specific data-client bags over a presentation catch-all on **/lib/**
+            patterns: [
+              '**/infrastructure/**',
+              '**/adapters/**',
+              '**/repositories/**',
+              '**/persistence/**',
+              'src/db/**',
+              'src/data/**',
+              'src/lib/db/**',
+              'src/lib/prisma/**',
+              'src/lib/supabase/**',
+              'src/lib/airtable/**',
+              'src/lib/firebase/**',
+              'src/lib/firestore/**',
+              'src/lib/mongodb/**',
+              'src/lib/mongoose/**',
+              'src/lib/drizzle/**',
+              'src/lib/kysely/**',
+              '**/lib/supabase/**',
+              '**/lib/airtable/**',
+              '**/lib/prisma/**',
+              '**/lib/db/**',
+            ],
+            exclude: FRAMEWORK_INTERNAL_EXCLUDE,
+            optional: true,
+          },
+          {
+            name: 'PresentationAdapters',
+            description: 'UI, routes, hooks, components (not a whole-src bag).',
+            // No **/src/** or bare **/lib/** — those swallowed data clients and forced false ENFORCE.
+            patterns: [
+              '**/components/**',
+              '**/hooks/**',
+              '**/routes/**',
+              '**/app/**',
+              '**/pages/**',
+              'src/app/**',
+              'src/pages/**',
+              'src/components/**',
+              'src/hooks/**',
+              'src/ui/**',
+              'src/layouts/**',
+              'app/**',
+              'pages/**',
+              'components/**',
+              // Next middleware edge entry (classic + Next 16 proxy rename)
+              'src/middleware.ts',
+              'src/middleware.js',
+              'middleware.ts',
+              'middleware.js',
+              'src/proxy.ts',
+              'src/proxy.js',
+              'proxy.ts',
+              'proxy.js',
+            ],
             exclude: FRAMEWORK_INTERNAL_EXCLUDE,
             optional: true,
           },
@@ -298,7 +359,20 @@ export const ARCHITECTURE_PRESETS = {
         rules: [
           { from: 'DomainModel', to: 'PresentationAdapters', allowed: false },
           { from: 'DomainModel', to: 'PersistenceAdapters', allowed: false },
-          { from: 'PresentationAdapters', to: 'PersistenceAdapters', allowed: false },
+          { from: 'DomainModel', to: 'ApplicationOrchestration', allowed: false },
+          { from: 'ApplicationOrchestration', to: 'PresentationAdapters', allowed: false },
+          // Next RSC often imports data clients from routes; deny is ideal but day-one
+          // ui-surface keeps this as a soft guidance edge (allowed) until ports exist —
+          // Persistence → Presentation stays denied when that edge appears.
+          {
+            from: 'PresentationAdapters',
+            to: 'PersistenceAdapters',
+            allowed: true,
+            message:
+              'UI/routes may reach data clients on day one (RSC); prefer application ports as the product grows.',
+          },
+          { from: 'PersistenceAdapters', to: 'PresentationAdapters', allowed: false },
+          { from: 'PersistenceAdapters', to: 'ApplicationOrchestration', allowed: false },
         ],
       },
       root

package/dist/index.cjs

@@ -80,7 +80,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/version.ts
-var version = "2.8.1";
+var version = "2.8.3";
 
 // src/kernel/intent/IntentRegistry.ts
 var IntentRegistry = class {