@eventmodelers/cli 1.0.45 → 1.0.46

package/stacks/node/templates/build-kit/lib/checks/10-slice-scope.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+// Everything staged in a slice commit must be inside the slice's own folder, or
+// one of the documented shared-infra exceptions a slice legitimately registers
+// *into* (never rewrites wholesale). See build-kit/lib/AGENT.md and the
+// build-state-view/build-automation SKILL.md files for what a compliant edit to
+// an exception file looks like. Migration files have their own dedicated check
+// (20-append-only-migrations.cjs), so they're allowed through here.
+
+const ALLOWED_EXCEPTIONS = [
+  /^src\/slices\/[^/]+\/[A-Za-z0-9]+Events\.ts$/, // per-context event union (append-only)
+  /^src\/common\/loadPostgresEventstore\.ts$/, // projection registration / schema.migrate()
+];
+
+const MIGRATION_PATTERN = /^migrations\/V\d+__.*\.sql$/;
+
+module.exports = {
+  name: 'slice-scope',
+  run(ctx) {
+    const violations = [];
+    for (const { path: p } of ctx.changes) {
+      if (ctx.SLICE_PATTERN.test(p)) continue;
+      if (MIGRATION_PATTERN.test(p)) continue;
+      if (ALLOWED_EXCEPTIONS.some((r) => r.test(p))) continue;
+      violations.push({ path: p, reason: 'outside src/slices/{context}/{slice}/ and not a documented exception' });
+    }
+    return violations;
+  },
+};

package/stacks/node/templates/build-kit/lib/checks/20-append-only-migrations.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+// migrations/V{n}__*.sql may only be ADDED, never modified or deleted — migrations
+// are append-only; a fix belongs in a new migration, not an edit to an old one.
+
+const MIGRATION_PATTERN = /^migrations\/V\d+__.*\.sql$/;
+
+module.exports = {
+  name: 'append-only-migrations',
+  run(ctx) {
+    const violations = [];
+    for (const { status, path: p } of ctx.changes) {
+      if (!MIGRATION_PATTERN.test(p)) continue;
+      if (status !== 'A') {
+        violations.push({ path: p, reason: 'existing migrations are append-only; add a new V{n} file instead of editing this one' });
+      }
+    }
+    return violations;
+  },
+};

package/stacks/node/templates/build-kit/lib/checks/30-test-file-present.cjs

@@ -0,0 +1,44 @@
+'use strict';
+
+// A slice commit that adds/changes a command handler, projection, or processor
+// must also include a *.test.ts for that slice — catches the agent skipping the
+// matching build skill's test step (build-state-change Step 4 / build-state-view
+// Step 5 / build-automation's DeciderSpecification tests).
+
+const { execSync } = require('child_process');
+
+const IMPLEMENTATION_FILE = /^src\/slices\/([^/]+)\/([^/]+)\/(?:[A-Za-z0-9]+Command|[A-Za-z0-9]+Projection|processor(?:-[A-Za-z0-9]+)?)\.ts$/;
+
+module.exports = {
+  name: 'test-file-present',
+  run(ctx) {
+    const sliceDirs = new Set();
+    for (const { path: p } of ctx.changes) {
+      const m = IMPLEMENTATION_FILE.exec(p);
+      if (m) sliceDirs.add(`src/slices/${m[1]}/${m[2]}`);
+    }
+    if (sliceDirs.size === 0) return [];
+
+    let tracked = [];
+    try {
+      tracked = execSync('git ls-files -- src/slices', { cwd: ctx.repoRoot, encoding: 'utf8' })
+        .split('\n')
+        .filter(Boolean);
+    } catch {
+      // best-effort — fall through with whatever's staged
+    }
+    const known = new Set([...tracked, ...ctx.changes.map((c) => c.path)]);
+
+    const violations = [];
+    for (const dir of sliceDirs) {
+      const hasTest = [...known].some((f) => f.startsWith(`${dir}/`) && f.endsWith('.test.ts'));
+      if (!hasTest) {
+        violations.push({
+          path: dir,
+          reason: 'no *.test.ts found for this slice — command handlers/projections/processors need test coverage',
+        });
+      }
+    }
+    return violations;
+  },
+};

package/stacks/node/templates/build-kit/lib/checks/40-no-invented-fields.cjs

@@ -0,0 +1,92 @@
+'use strict';
+
+// Heuristic: flags a field name used in a slice's Command/ReadModel type literal
+// that doesn't appear anywhere in that slice's own slice.json. Not a real
+// TS/schema-aware check (no parser dependency) — it regex-extracts the fields
+// declared inside `Command<'Name', { ... }, ...>` and `type XReadModel = { ... }`
+// literals, so unusual formatting (nested object/array field types, nonstandard
+// generics) can slip past undetected. It only ever adds violations for fields it
+// is confident about; when slice.json can't be found/parsed for a slice, that
+// slice's files are skipped entirely rather than guessed at.
+
+const fs = require('fs');
+const path = require('path');
+const { findSliceJson, normalize } = require('../util/find-slice.cjs');
+
+const COMMON_ALLOWED = new Set(
+  ['id', 'userId', 'correlationId', 'causationId', 'streamName', 'type', 'data', 'metadata', 'createdAt', 'updatedAt', 'timestamp'].map(normalize),
+);
+
+const TYPE_LITERALS = [
+  /(?:Command|Event)<\s*'[^']+'\s*,\s*{([^}]*)}/g,
+  /type\s+[A-Za-z0-9_]+ReadModel\s*=\s*{([^}]*)}/g,
+];
+
+const FIELD_LINE = /^\s*([A-Za-z_][A-Za-z0-9_]*)\??\s*:/gm;
+
+function collectDeclaredFields(node, out) {
+  if (Array.isArray(node)) {
+    for (const item of node) collectDeclaredFields(item, out);
+  } else if (node && typeof node === 'object') {
+    if (typeof node.name === 'string' && ('type' in node || 'optional' in node)) {
+      out.add(normalize(node.name));
+    }
+    for (const key of Object.keys(node)) collectDeclaredFields(node[key], out);
+  }
+}
+
+module.exports = {
+  name: 'no-invented-fields',
+  run(ctx) {
+    const bySlice = new Map(); // "context/SliceName" -> { context, sliceName, files: [] }
+
+    for (const { path: p } of ctx.changes) {
+      if (!p.endsWith('.ts') || p.endsWith('.test.ts')) continue;
+      const m = /^src\/slices\/([^/]+)\/([^/]+)\//.exec(p);
+      if (!m) continue;
+      const key = `${m[1]}/${m[2]}`;
+      if (!bySlice.has(key)) bySlice.set(key, { context: m[1], sliceName: m[2], files: [] });
+      bySlice.get(key).files.push(p);
+    }
+
+    const violations = [];
+
+    for (const { context, sliceName, files } of bySlice.values()) {
+      const slice = findSliceJson(ctx.repoRoot, context, sliceName);
+      if (!slice) continue; // can't verify — don't block
+
+      const declared = new Set();
+      collectDeclaredFields(slice, declared);
+      if (declared.size === 0) continue; // slice.json shape not recognized — don't block
+
+      for (const file of files) {
+        let content;
+        try {
+          content = fs.readFileSync(path.join(ctx.repoRoot, file), 'utf8');
+        } catch {
+          continue; // deleted/unreadable — nothing to check
+        }
+
+        for (const pattern of TYPE_LITERALS) {
+          pattern.lastIndex = 0;
+          let typeMatch;
+          while ((typeMatch = pattern.exec(content))) {
+            FIELD_LINE.lastIndex = 0;
+            let fieldMatch;
+            while ((fieldMatch = FIELD_LINE.exec(typeMatch[1]))) {
+              const raw = fieldMatch[1];
+              const norm = normalize(raw);
+              if (COMMON_ALLOWED.has(norm) || declared.has(norm)) continue;
+              violations.push({
+                path: file,
+                reason: `field "${raw}" is not declared anywhere in slice.json for this slice — check for an invented field`,
+              });
+            }
+          }
+        }
+      }
+    }
+
+    return violations;
+  },
+};

package/stacks/node/templates/build-kit/lib/checks/50-spec-coverage.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+// Heuristic: a slice's *.test.ts must have at least as many `it(...)` blocks as
+// slice.json has `specifications[]` entries. Doesn't verify each spec is
+// actually tested (that would need matching scenario content, not just count),
+// just that nobody's silently short a test case. Skipped (not blocked) when
+// slice.json can't be found or has no specifications[] array.
+
+const fs = require('fs');
+const path = require('path');
+const { findSliceJson } = require('../util/find-slice.cjs');
+
+const TEST_FILE = /^src\/slices\/([^/]+)\/([^/]+)\/[^/]+\.test\.ts$/;
+const IT_BLOCK = /\bit(?:\.(?:only|skip))?\s*\(/g;
+
+module.exports = {
+  name: 'spec-coverage',
+  run(ctx) {
+    const violations = [];
+
+    for (const { path: p } of ctx.changes) {
+      TEST_FILE.lastIndex = 0;
+      const m = TEST_FILE.exec(p);
+      if (!m) continue;
+      const [, context, sliceName] = m;
+
+      const slice = findSliceJson(ctx.repoRoot, context, sliceName);
+      if (!slice || !Array.isArray(slice.specifications) || slice.specifications.length === 0) continue;
+
+      let content;
+      try {
+        content = fs.readFileSync(path.join(ctx.repoRoot, p), 'utf8');
+      } catch {
+        continue; // deleted — nothing to check
+      }
+
+      const specCount = slice.specifications.length;
+      const itCount = (content.match(IT_BLOCK) || []).length;
+
+      if (itCount < specCount) {
+        violations.push({
+          path: p,
+          reason: `slice.json declares ${specCount} specification(s) but this test file only has ${itCount} it(...) block(s)`,
+        });
+      }
+    }
+
+    return violations;
+  },
+};

package/stacks/node/templates/build-kit/lib/checks/90-tsc-build.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+// The project must still typecheck after the slice change. Uses the project's
+// own `typescript` devDependency via `npx tsc --noEmit` — no new dependency,
+// but it does mean this check needs node_modules already installed (same
+// prerequisite `npm run build` already has).
+
+const { execSync } = require('child_process');
+
+module.exports = {
+  name: 'tsc-build',
+  skipIfAlreadyFailing: true, // slow — don't bother once the commit is rejected already
+  run(ctx) {
+    try {
+      execSync('npx tsc --noEmit', { cwd: ctx.repoRoot, stdio: 'pipe' });
+      return [];
+    } catch (err) {
+      const output = String(err.stdout || err.message || '').trim().split('\n').slice(0, 20).join('\n');
+      return [{ path: '(tsc --noEmit)', reason: `TypeScript build failed:\n${output}` }];
+    }
+  },
+};

package/stacks/node/templates/root/.githooks/pre-commit

@@ -0,0 +1,11 @@
+#!/bin/sh
+# Installed via setup-env.sh (`git config core.hooksPath .githooks`), so this file
+# is versioned and shared by every clone instead of living only in .git/hooks/.
+set -e
+
+repo_root=$(git rev-parse --show-toplevel)
+script="$repo_root/.build-kit/lib/check-commit-scope.cjs"
+
+if [ -f "$script" ]; then
+  node "$script"
+fi

package/stacks/node/templates/root/package.json

@@ -7,7 +7,8 @@
     "dev": "node --env-file=.env --require ts-node/register server.ts",
     "build": "tsc",
     "start": "NODE_ENV=production node --env-file=.env --require ts-node/register server.ts",
-    "test": "tsx --test 'src/**/*.test.ts'"
+    "test": "tsx --test 'src/**/*.test.ts'",
+    "check:scope": "node .build-kit/lib/check-commit-scope.cjs"
   },
   "dependencies": {
     "@event-driven-io/emmett": "^0.42.1-alpha.1",

package/stacks/node/templates/root/setup-env.sh

@@ -50,4 +50,10 @@ FLYWAY_PASSWORD=${DB_PASSWORD}
 EOF
 
 echo ""
-echo ".env created successfully."
+echo ".env created successfully."
+
+if [ -f .githooks/pre-commit ] && git rev-parse --git-dir >/dev/null 2>&1; then
+  chmod +x .githooks/pre-commit 2>/dev/null || true
+  git config core.hooksPath .githooks
+  echo "Configured git to use .githooks/ (slice commit-scope guard)."
+fi