@macedon-technologies/batman 1.24.2 → 1.25.0

package/.jsii

@@ -1283,6 +1283,6 @@
       "symbolId": "src/WorkflowAutoDiscover:WorkflowAutoDiscover"
     }
   },
-  "version": "1.24.2",
-  "fingerprint": "sFp7ZrQrJJb11FaUQc/GxMRUFHD1UgQNfu8HQP7LoGM="
+  "version": "1.25.0",
+  "fingerprint": "PndeNL5NXQb1TkD3BzT8gxANwXiAJBG0k+/ZMUVENRk="
 }

package/architecture-rules/README.md

@@ -9,6 +9,9 @@ needs a genuinely new kind of check.
 
 ## Rule shape
 
+Two `check.type`s are implemented: `forbidden-import` (whole-repo import-graph
+check) and `required-companion` (diff-based co-change check).
+
 ```json
 {
   "id": "unique-id",
@@ -23,6 +26,56 @@ needs a genuinely new kind of check.
 }
 ```
 
+```json
+{
+  "id": "unique-id",
+  "description": "What this enforces and why.",
+  "enabled": true,
+  "severity": "low" | "medium" | "high" | "critical",
+  "check": {
+    "type": "required-companion",
+    "from": ["glob patterns selecting changed files that trigger the requirement"],
+    "requireOneOf": ["glob patterns -- at least one CHANGED file must match one of these"],
+    "exempt": ["optional -- from-files matching these globs don't trigger the requirement"]
+  }
+}
+```
+
+`required-companion` evaluates the set of files changed in the current diff
+(`git diff --name-only --diff-filter=ACMR <baseRef>...HEAD`), not the whole
+repo tree: if any changed file matches `from` (and doesn't match `exempt`) but
+no changed file matches `requireOneOf`, that's a violation. The base ref
+defaults to `origin/main` and can be overridden with the
+`ARCHITECTURE_RULES_BASE_REF` environment variable. This means the checkout
+running `pnpm validate:architecture` must have that base ref fetched and
+resolvable (a shallow, single-branch checkout will make the check fail closed
+with an error rather than silently reporting no violations) — make sure
+whatever runs this task fetches enough history for `git diff <baseRef>...HEAD`
+to succeed.
+
+`from`/`requireOneOf`/`exempt` globs are matched against the paths `git
+diff --name-only` reports, which are relative to the git repository's
+top-level directory. This lines up with `from`'s own directory (the parent of
+`architecture-rules/`) in the common case — a single project generated at the
+repo root — but if `architecture-rules/` instead lives under a nested
+subdirectory of a larger git repo, write globs relative to the git root, not
+to that subdirectory.
+
+**`required-companion` is a coverage check, not a correctness check.** It only
+confirms that *some* changed file matches `requireOneOf` — it can't tell
+whether that change is actually related to the triggering `from` change (a
+trivial or unrelated edit to a file under `requireOneOf` satisfies the rule
+just as well as a substantive one), and it can't tell whether a given `from`
+change genuinely needed a companion at all (a pure refactor might not).
+`exempt` covers *known, glob-expressible* exceptions, but not every false
+positive is expressible as a glob — that judgment call still belongs to the
+rule author (scoping `from`/`exempt`) and the reviewer (reading the companion
+diff, not just trusting that the check passed). Also note that `main()`
+fails the whole run on *any* violation regardless of `severity` — `severity`
+is informational only, not a leniency lever — so start with a narrowly
+scoped `from` (or `enabled: false`) and widen it as the convention proves
+itself, the same guidance as for `forbidden-import`.
+
 `enabled: false` rules are skipped (reported as "deferred") rather than
 evaluated — use this for a rule you've named and described but don't yet
 have a concrete convention to check.
@@ -35,8 +88,10 @@ conventions solidify (e.g. an event-sourced/CQRS module layout under
 
 ## Adding a check type
 
-`forbidden-import` is the only implemented `check.type`. If a future rule
-needs something it can't express (e.g. "every aggregate file must have a
-matching events file"), add a new `type` value, a matching interface, and a
-case in `evaluateRule()` in `check.ts` — keep the engine itself generic;
-rule-specific knowledge belongs in `rules.json`.
+`forbidden-import` (whole-repo import graph) and `required-companion`
+(diff-based co-change) are the implemented `check.type`s. If a future rule
+needs a data source neither provides (e.g. "every aggregate file must have a
+matching events file", which is a repo-wide naming convention rather than
+either an import-graph or a diff check), add a new `type` value, a matching
+interface, and a case in `evaluateRule()` in `check.ts` — keep the engine
+itself generic; rule-specific knowledge belongs in `rules.json`.

package/architecture-rules/check.ts

@@ -6,6 +6,7 @@
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import { execFileSync } from 'node:child_process';
 import rulesFile from './rules.json';
 
 interface ForbiddenImportCheck {
@@ -16,12 +17,22 @@ interface ForbiddenImportCheck {
   forbid: string[];
 }
 
+interface RequiredCompanionCheck {
+  type: 'required-companion';
+  // Glob patterns selecting changed files that trigger the requirement.
+  from: string[];
+  // Glob patterns -- at least one CHANGED file must match one of these.
+  requireOneOf: string[];
+  // Optional -- 'from' files matching these globs don't trigger the requirement.
+  exempt?: string[];
+}
+
 interface Rule {
   id: string;
   description: string;
   enabled: boolean;
   severity: 'low' | 'medium' | 'high' | 'critical';
-  check: ForbiddenImportCheck;
+  check: ForbiddenImportCheck | RequiredCompanionCheck;
 }
 
 interface Violation {
@@ -32,6 +43,7 @@ interface Violation {
 
 const REPO_ROOT = path.resolve(__dirname, '..');
 const IGNORED_DIRS = new Set(['node_modules', '.git', '.swamp', 'cdk.out', 'lib', 'build', 'dist']);
+const BASE_REF = process.env.ARCHITECTURE_RULES_BASE_REF || 'origin/main';
 
 // Minimal glob -> RegExp: supports "*", "**", "**/" and literal path segments.
 // No new dependency for this — the only pattern shapes rules.json ever needs
@@ -69,6 +81,26 @@ function toRepoRelative(absPath: string): string {
   return path.relative(REPO_ROOT, absPath).split(path.sep).join('/');
 }
 
+// Files changed relative to baseRef, sourced from git rather than the whole-tree
+// walk() below -- required-companion checks care about what a PR touched, not
+// the full repo. Throws (rather than returning []) if baseRef cannot be resolved,
+// so an unfetched base ref fails the check instead of silently reporting no violations.
+function getChangedFiles(baseRef: string): string[] {
+  let output: string;
+  try {
+    output = execFileSync('git', ['diff', '--name-only', '--diff-filter=ACMR', `${baseRef}...HEAD`], {
+      cwd: REPO_ROOT,
+      encoding: 'utf8',
+    });
+  } catch (err) {
+    throw new Error(
+      `architecture-rules: failed to compute the changed-file set against base ref "${baseRef}" -- ` +
+        `is it fetched and resolvable in this checkout? (${(err as Error).message})`,
+    );
+  }
+  return output.split('\n').map((line) => line.trim()).filter((line) => line.length > 0);
+}
+
 function walk(dir: string, acc: string[] = []): string[] {
   for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
     if (IGNORED_DIRS.has(entry.name)) continue;
@@ -103,7 +135,7 @@ function resolvedCandidates(fromFile: string, spec: string): string[] {
 }
 
 function evaluateForbiddenImport(rule: Rule): Violation[] {
-  const { from, forbid } = rule.check;
+  const { from, forbid } = rule.check as ForbiddenImportCheck;
   if (from.length === 0 || forbid.length === 0) return [];
 
   const violations: Violation[] = [];
@@ -126,10 +158,34 @@ function evaluateForbiddenImport(rule: Rule): Violation[] {
   return violations;
 }
 
+function evaluateRequiredCompanion(rule: Rule): Violation[] {
+  const { from, requireOneOf, exempt } = rule.check as RequiredCompanionCheck;
+  if (from.length === 0 || requireOneOf.length === 0) return [];
+
+  const changedFiles = getChangedFiles(BASE_REF);
+  const triggering = changedFiles.filter(
+    (file) => matchesAny(file, from) && !(exempt && matchesAny(file, exempt)),
+  );
+  if (triggering.length === 0) return [];
+
+  const satisfied = changedFiles.some((file) => matchesAny(file, requireOneOf));
+  if (satisfied) return [];
+
+  return [
+    {
+      ruleId: rule.id,
+      severity: rule.severity,
+      message: `changed file(s) ${triggering.join(', ')} match rule "${rule.id}"'s "from" patterns, but no changed file matches its "requireOneOf" patterns`,
+    },
+  ];
+}
+
 function evaluateRule(rule: Rule): Violation[] {
   switch (rule.check.type) {
     case 'forbidden-import':
       return evaluateForbiddenImport(rule);
+    case 'required-companion':
+      return evaluateRequiredCompanion(rule);
     default:
       throw new Error(`architecture-rules: unknown check.type "${(rule.check as { type: string }).type}" on rule "${rule.id}"`);
   }

package/lib/BatmanProject.js

@@ -12,7 +12,7 @@ const SoftwareFactoryFiles_1 = require("./SoftwareFactoryFiles");
 const utils_1 = require("./utils");
 const ViteReactProject_1 = require("./ViteReactProject");
 class BatmanProject extends awscdk_1.AwsCdkTypeScriptApp {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.BatmanProject", version: "1.24.2" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.BatmanProject", version: "1.25.0" };
     constructor(options) {
         super({
             ...options,

package/lib/BootcampProject.js

@@ -12,7 +12,7 @@ const SoftwareFactoryFiles_1 = require("./SoftwareFactoryFiles");
 const utils_1 = require("./utils");
 const ViteReactProject_1 = require("./ViteReactProject");
 class BootcampProject extends awscdk_1.AwsCdkTypeScriptApp {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.BootcampProject", version: "1.24.2" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.BootcampProject", version: "1.25.0" };
     constructor(options) {
         super({
             ...options,

package/lib/CodeOwnersFile.js

@@ -4,7 +4,7 @@ exports.CodeOwnersFile = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const projen_1 = require("projen");
 class CodeOwnersFile extends projen_1.TextFile {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.CodeOwnersFile", version: "1.24.2" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.CodeOwnersFile", version: "1.25.0" };
     constructor(project, options = {}) {
         const defaultOwners = ['* @macedon-technologies/platform', '* @macedon-technologies/ai-development-team'];
         const allOwners = [...defaultOwners, ...(options.additionalOwners || [])];

package/lib/ProductionDeployWorkflow.js

@@ -7,7 +7,7 @@ const javascript_1 = require("projen/lib/javascript");
 const utils_1 = require("./utils");
 const WorkflowActionVersions_1 = require("./WorkflowActionVersions");
 class ProductionDeployWorkflow extends projen_1.YamlFile {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.ProductionDeployWorkflow", version: "1.24.2" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.ProductionDeployWorkflow", version: "1.25.0" };
     constructor(project, options) {
         const packageManager = project.package.packageManager;
         const actionVersions = (0, WorkflowActionVersions_1.resolveActionVersions)(options.actionVersions);

package/lib/SoftwareFactoryArchitectureRules.js

@@ -21,6 +21,7 @@ class SoftwareFactoryArchitectureRules {
                 ' */',
                 "import * as fs from 'node:fs';",
                 "import * as path from 'node:path';",
+                "import { execFileSync } from 'node:child_process';",
                 "import rulesFile from './rules.json';",
                 '',
                 'interface ForbiddenImportCheck {',
@@ -31,12 +32,22 @@ class SoftwareFactoryArchitectureRules {
                 '  forbid: string[];',
                 '}',
                 '',
+                'interface RequiredCompanionCheck {',
+                "  type: 'required-companion';",
+                '  // Glob patterns selecting changed files that trigger the requirement.',
+                '  from: string[];',
+                '  // Glob patterns -- at least one CHANGED file must match one of these.',
+                '  requireOneOf: string[];',
+                "  // Optional -- 'from' files matching these globs don't trigger the requirement.",
+                '  exempt?: string[];',
+                '}',
+                '',
                 'interface Rule {',
                 '  id: string;',
                 '  description: string;',
                 '  enabled: boolean;',
                 "  severity: 'low' | 'medium' | 'high' | 'critical';",
-                '  check: ForbiddenImportCheck;',
+                '  check: ForbiddenImportCheck | RequiredCompanionCheck;',
                 '}',
                 '',
                 'interface Violation {',
@@ -47,6 +58,7 @@ class SoftwareFactoryArchitectureRules {
                 '',
                 "const REPO_ROOT = path.resolve(__dirname, '..');",
                 "const IGNORED_DIRS = new Set(['node_modules', '.git', '.swamp', 'cdk.out', 'lib', 'build', 'dist']);",
+                "const BASE_REF = process.env.ARCHITECTURE_RULES_BASE_REF || 'origin/main';",
                 '',
                 '// Minimal glob -> RegExp: supports "*", "**", "**/" and literal path segments.',
                 '// No new dependency for this — the only pattern shapes rules.json ever needs',
@@ -84,6 +96,26 @@ class SoftwareFactoryArchitectureRules {
                 "  return path.relative(REPO_ROOT, absPath).split(path.sep).join('/');",
                 '}',
                 '',
+                '// Files changed relative to baseRef, sourced from git rather than the whole-tree',
+                '// walk() below -- required-companion checks care about what a PR touched, not',
+                '// the full repo. Throws (rather than returning []) if baseRef cannot be resolved,',
+                '// so an unfetched base ref fails the check instead of silently reporting no violations.',
+                'function getChangedFiles(baseRef: string): string[] {',
+                '  let output: string;',
+                '  try {',
+                "    output = execFileSync('git', ['diff', '--name-only', '--diff-filter=ACMR', `${baseRef}...HEAD`], {",
+                '      cwd: REPO_ROOT,',
+                "      encoding: 'utf8',",
+                '    });',
+                '  } catch (err) {',
+                '    throw new Error(',
+                '      `architecture-rules: failed to compute the changed-file set against base ref "${baseRef}" -- ` +',
+                '        `is it fetched and resolvable in this checkout? (${(err as Error).message})`,',
+                '    );',
+                '  }',
+                "  return output.split('\\n').map((line) => line.trim()).filter((line) => line.length > 0);",
+                '}',
+                '',
                 'function walk(dir: string, acc: string[] = []): string[] {',
                 '  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {',
                 '    if (IGNORED_DIRS.has(entry.name)) continue;',
@@ -118,7 +150,7 @@ class SoftwareFactoryArchitectureRules {
                 '}',
                 '',
                 'function evaluateForbiddenImport(rule: Rule): Violation[] {',
-                '  const { from, forbid } = rule.check;',
+                '  const { from, forbid } = rule.check as ForbiddenImportCheck;',
                 '  if (from.length === 0 || forbid.length === 0) return [];',
                 '',
                 '  const violations: Violation[] = [];',
@@ -141,10 +173,34 @@ class SoftwareFactoryArchitectureRules {
                 '  return violations;',
                 '}',
                 '',
+                'function evaluateRequiredCompanion(rule: Rule): Violation[] {',
+                '  const { from, requireOneOf, exempt } = rule.check as RequiredCompanionCheck;',
+                '  if (from.length === 0 || requireOneOf.length === 0) return [];',
+                '',
+                '  const changedFiles = getChangedFiles(BASE_REF);',
+                '  const triggering = changedFiles.filter(',
+                '    (file) => matchesAny(file, from) && !(exempt && matchesAny(file, exempt)),',
+                '  );',
+                '  if (triggering.length === 0) return [];',
+                '',
+                '  const satisfied = changedFiles.some((file) => matchesAny(file, requireOneOf));',
+                '  if (satisfied) return [];',
+                '',
+                '  return [',
+                '    {',
+                '      ruleId: rule.id,',
+                '      severity: rule.severity,',
+                '      message: `changed file(s) ${triggering.join(\', \')} match rule "${rule.id}"\'s "from" patterns, but no changed file matches its "requireOneOf" patterns`,',
+                '    },',
+                '  ];',
+                '}',
+                '',
                 'function evaluateRule(rule: Rule): Violation[] {',
                 '  switch (rule.check.type) {',
                 "    case 'forbidden-import':",
                 '      return evaluateForbiddenImport(rule);',
+                "    case 'required-companion':",
+                '      return evaluateRequiredCompanion(rule);',
                 '    default:',
                 '      throw new Error(`architecture-rules: unknown check.type "${(rule.check as { type: string }).type}" on rule "${rule.id}"`);',
                 '  }',
@@ -203,6 +259,9 @@ class SoftwareFactoryArchitectureRules {
                 '',
                 '## Rule shape',
                 '',
+                'Two `check.type`s are implemented: `forbidden-import` (whole-repo import-graph',
+                'check) and `required-companion` (diff-based co-change check).',
+                '',
                 '```json',
                 '{',
                 '  "id": "unique-id",',
@@ -217,6 +276,56 @@ class SoftwareFactoryArchitectureRules {
                 '}',
                 '```',
                 '',
+                '```json',
+                '{',
+                '  "id": "unique-id",',
+                '  "description": "What this enforces and why.",',
+                '  "enabled": true,',
+                '  "severity": "low" | "medium" | "high" | "critical",',
+                '  "check": {',
+                '    "type": "required-companion",',
+                '    "from": ["glob patterns selecting changed files that trigger the requirement"],',
+                '    "requireOneOf": ["glob patterns -- at least one CHANGED file must match one of these"],',
+                '    "exempt": ["optional -- from-files matching these globs don\'t trigger the requirement"]',
+                '  }',
+                '}',
+                '```',
+                '',
+                '`required-companion` evaluates the set of files changed in the current diff',
+                '(`git diff --name-only --diff-filter=ACMR <baseRef>...HEAD`), not the whole',
+                'repo tree: if any changed file matches `from` (and doesn\'t match `exempt`) but',
+                'no changed file matches `requireOneOf`, that\'s a violation. The base ref',
+                'defaults to `origin/main` and can be overridden with the',
+                '`ARCHITECTURE_RULES_BASE_REF` environment variable. This means the checkout',
+                'running `pnpm validate:architecture` must have that base ref fetched and',
+                'resolvable (a shallow, single-branch checkout will make the check fail closed',
+                'with an error rather than silently reporting no violations) — make sure',
+                'whatever runs this task fetches enough history for `git diff <baseRef>...HEAD`',
+                'to succeed.',
+                '',
+                '`from`/`requireOneOf`/`exempt` globs are matched against the paths `git',
+                'diff --name-only` reports, which are relative to the git repository\'s',
+                'top-level directory. This lines up with `from`\'s own directory (the parent of',
+                '`architecture-rules/`) in the common case — a single project generated at the',
+                'repo root — but if `architecture-rules/` instead lives under a nested',
+                'subdirectory of a larger git repo, write globs relative to the git root, not',
+                'to that subdirectory.',
+                '',
+                '**`required-companion` is a coverage check, not a correctness check.** It only',
+                'confirms that *some* changed file matches `requireOneOf` — it can\'t tell',
+                'whether that change is actually related to the triggering `from` change (a',
+                'trivial or unrelated edit to a file under `requireOneOf` satisfies the rule',
+                'just as well as a substantive one), and it can\'t tell whether a given `from`',
+                'change genuinely needed a companion at all (a pure refactor might not).',
+                '`exempt` covers *known, glob-expressible* exceptions, but not every false',
+                'positive is expressible as a glob — that judgment call still belongs to the',
+                'rule author (scoping `from`/`exempt`) and the reviewer (reading the companion',
+                'diff, not just trusting that the check passed). Also note that `main()`',
+                'fails the whole run on *any* violation regardless of `severity` — `severity`',
+                'is informational only, not a leniency lever — so start with a narrowly',
+                'scoped `from` (or `enabled: false`) and widen it as the convention proves',
+                'itself, the same guidance as for `forbidden-import`.',
+                '',
                 '`enabled: false` rules are skipped (reported as "deferred") rather than',
                 "evaluated — use this for a rule you've named and described but don't yet",
                 'have a concrete convention to check.',
@@ -229,11 +338,13 @@ class SoftwareFactoryArchitectureRules {
                 '',
                 '## Adding a check type',
                 '',
-                '`forbidden-import` is the only implemented `check.type`. If a future rule',
-                'needs something it can\'t express (e.g. "every aggregate file must have a',
-                'matching events file"), add a new `type` value, a matching interface, and a',
-                'case in `evaluateRule()` in `check.ts` — keep the engine itself generic;',
-                'rule-specific knowledge belongs in `rules.json`.',
+                '`forbidden-import` (whole-repo import graph) and `required-companion`',
+                '(diff-based co-change) are the implemented `check.type`s. If a future rule',
+                'needs a data source neither provides (e.g. "every aggregate file must have a',
+                'matching events file", which is a repo-wide naming convention rather than',
+                'either an import-graph or a diff check), add a new `type` value, a matching',
+                'interface, and a case in `evaluateRule()` in `check.ts` — keep the engine',
+                'itself generic; rule-specific knowledge belongs in `rules.json`.',
             ],
         });
         new projen_1.SampleFile(project, 'architecture-rules/rules.json', {
@@ -242,4 +353,4 @@ class SoftwareFactoryArchitectureRules {
     }
 }
 exports.SoftwareFactoryArchitectureRules = SoftwareFactoryArchitectureRules;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SoftwareFactoryArchitectureRules.js","sourceRoot":"","sources":["../src/SoftwareFactoryArchitectureRules.ts"],"names":[],"mappings":"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","sourcesContent":["import { JsonFile, SampleFile, TextFile } from 'projen';\nimport { NodeProject } from 'projen/lib/javascript';\n\n/**\n * The generic, data-driven architecture rule engine plus an empty seed\n * rules.json. `check.ts`/`tsconfig.json`/`README.md` are managed (Batman\n * owns the engine); `rules.json` is a `SampleFile` — each repo's own rules\n * are data the team owns, not something Batman should overwrite.\n */\nexport class SoftwareFactoryArchitectureRules {\n  constructor(project: NodeProject) {\n    new TextFile(project, 'architecture-rules/check.ts', {\n      marker: true,\n      lines: [\n        '/**',\n        ' * Generic architecture-rule engine. Rules live entirely in rules.json — this',\n        ' * file only knows how to evaluate the check \"types\" that rules can declare.',\n        ' * Add a new rule by adding a rules.json entry; add a new check type by adding',\n        ' * a case in evaluateRule().',\n        ' */',\n        \"import * as fs from 'node:fs';\",\n        \"import * as path from 'node:path';\",\n        \"import rulesFile from './rules.json';\",\n        '',\n        'interface ForbiddenImportCheck {',\n        \"  type: 'forbidden-import';\",\n        '  // Glob patterns (relative to repo root) selecting the files this rule inspects.',\n        '  from: string[];',\n        '  // Glob patterns (relative to repo root) that \"from\" files may not import from.',\n        '  forbid: string[];',\n        '}',\n        '',\n        'interface Rule {',\n        '  id: string;',\n        '  description: string;',\n        '  enabled: boolean;',\n        \"  severity: 'low' | 'medium' | 'high' | 'critical';\",\n        '  check: ForbiddenImportCheck;',\n        '}',\n        '',\n        'interface Violation {',\n        '  ruleId: string;',\n        '  severity: string;',\n        '  message: string;',\n        '}',\n        '',\n        \"const REPO_ROOT = path.resolve(__dirname, '..');\",\n        \"const IGNORED_DIRS = new Set(['node_modules', '.git', '.swamp', 'cdk.out', 'lib', 'build', 'dist']);\",\n        '',\n        '// Minimal glob -> RegExp: supports \"*\", \"**\", \"**/\" and literal path segments.',\n        '// No new dependency for this — the only pattern shapes rules.json ever needs',\n        '// are directory-prefix globs like \"src/domains/*/commands/**\".',\n        'function globToRegExp(glob: string): RegExp {',\n        \"  let out = '';\",\n        '  for (let i = 0; i < glob.length; i++) {',\n        '    const c = glob[i];',\n        \"    if (c === '*' && glob[i + 1] === '*') {\",\n        '      i++;',\n        \"      if (glob[i + 1] === '/') {\",\n        \"        out += '(?:.*/)?';\",\n        '        i++;',\n        '      } else {',\n        \"        out += '.*';\",\n        '      }',\n        \"    } else if (c === '*') {\",\n        \"      out += '[^/]*';\",\n        \"    } else if (c === '?') {\",\n        \"      out += '[^/]';\",\n        \"    } else if ('.+^${}()|[]\\\\\\\\'.includes(c)) {\",\n        '      out += `\\\\\\\\${c}`;',\n        '    } else {',\n        '      out += c;',\n        '    }',\n        '  }',\n        '  return new RegExp(`^${out}$`);',\n        '}',\n        '',\n        'function matchesAny(relFile: string, globs: string[]): boolean {',\n        '  return globs.some((glob) => globToRegExp(glob).test(relFile));',\n        '}',\n        '',\n        'function toRepoRelative(absPath: string): string {',\n        \"  return path.relative(REPO_ROOT, absPath).split(path.sep).join('/');\",\n        '}',\n        '',\n        'function walk(dir: string, acc: string[] = []): string[] {',\n        '  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {',\n        '    if (IGNORED_DIRS.has(entry.name)) continue;',\n        '    const full = path.join(dir, entry.name);',\n        '    if (entry.isDirectory()) {',\n        '      walk(full, acc);',\n        \"    } else if (entry.isFile() && (entry.name.endsWith('.ts') || entry.name.endsWith('.tsx'))) {\",\n        '      acc.push(full);',\n        '    }',\n        '  }',\n        '  return acc;',\n        '}',\n        '',\n        \"const RELATIVE_IMPORT_RE = /(?:import|export)\\\\s+(?:[^'\\\";]*?\\\\bfrom\\\\s+)?['\\\"](\\\\.[^'\\\"]+)['\\\"]/g;\",\n        '',\n        'function findRelativeImports(source: string): string[] {',\n        '  const specs: string[] = [];',\n        '  RELATIVE_IMPORT_RE.lastIndex = 0;',\n        '  let match: RegExpExecArray | null;',\n        '  while ((match = RELATIVE_IMPORT_RE.exec(source))) {',\n        '    specs.push(match[1]);',\n        '  }',\n        '  return specs;',\n        '}',\n        '',\n        '// An import spec resolves to a module, not a specific file extension, so a',\n        '// forbid glob is checked against the bare resolved path plus its .ts/index.ts',\n        '// variants.',\n        'function resolvedCandidates(fromFile: string, spec: string): string[] {',\n        '  const resolved = toRepoRelative(path.normalize(path.join(path.dirname(fromFile), spec)));',\n        '  return [resolved, `${resolved}.ts`, `${resolved}/index.ts`];',\n        '}',\n        '',\n        'function evaluateForbiddenImport(rule: Rule): Violation[] {',\n        '  const { from, forbid } = rule.check;',\n        '  if (from.length === 0 || forbid.length === 0) return [];',\n        '',\n        '  const violations: Violation[] = [];',\n        '  for (const file of walk(REPO_ROOT)) {',\n        '    const relFile = toRepoRelative(file);',\n        '    if (!matchesAny(relFile, from)) continue;',\n        '',\n        \"    const source = fs.readFileSync(file, 'utf8');\",\n        '    for (const spec of findRelativeImports(source)) {',\n        '      const candidates = resolvedCandidates(file, spec);',\n        '      if (candidates.some((candidate) => matchesAny(candidate, forbid))) {',\n        '        violations.push({',\n        '          ruleId: rule.id,',\n        '          severity: rule.severity,',\n        '          message: `${relFile} imports \"${spec}\", which resolves under a path forbidden by rule \"${rule.id}\"`,',\n        '        });',\n        '      }',\n        '    }',\n        '  }',\n        '  return violations;',\n        '}',\n        '',\n        'function evaluateRule(rule: Rule): Violation[] {',\n        '  switch (rule.check.type) {',\n        \"    case 'forbidden-import':\",\n        '      return evaluateForbiddenImport(rule);',\n        '    default:',\n        '      throw new Error(`architecture-rules: unknown check.type \"${(rule.check as { type: string }).type}\" on rule \"${rule.id}\"`);',\n        '  }',\n        '}',\n        '',\n        'function main(): number {',\n        '  const rules = (rulesFile as { rules: Rule[] }).rules;',\n        '  let evaluated = 0;',\n        '  let deferred = 0;',\n        '  const violations: Violation[] = [];',\n        '',\n        '  for (const rule of rules) {',\n        '    if (!rule.enabled) {',\n        '      deferred++;',\n        '      console.log(`[deferred] ${rule.id}: ${rule.description}`);',\n        '      continue;',\n        '    }',\n        '    evaluated++;',\n        '    violations.push(...evaluateRule(rule));',\n        '  }',\n        '',\n        '  console.log(`\\\\narchitecture-rules: ${evaluated} rule(s) evaluated, ${deferred} deferred, ${violations.length} violation(s)`);',\n        '  for (const violation of violations) {',\n        '    console.error(`  [${violation.severity}] ${violation.ruleId}: ${violation.message}`);',\n        '  }',\n        '',\n        '  return violations.length > 0 ? 1 : 0;',\n        '}',\n        '',\n        'process.exit(main());',\n      ],\n    });\n\n    new JsonFile(project, 'architecture-rules/tsconfig.json', {\n      marker: false,\n      obj: {\n        extends: '../tsconfig.json',\n        compilerOptions: {\n          noEmit: true,\n          rootDir: '.',\n        },\n        include: ['*.ts', '*.json'],\n        exclude: ['node_modules'],\n      },\n    });\n\n    new TextFile(project, 'architecture-rules/README.md', {\n      marker: true,\n      lines: [\n        '# Architecture rules',\n        '',\n        'A data-driven registry of architectural constraints, enforced by',\n        '`pnpm validate:architecture` and run as part of the pre-PR verification',\n        'workflow (`workflows/workflow-pre-pr-verify.yaml`) before the swamp factory',\n        'opens a PR. New rules are new entries in `rules.json`, not new code — the',\n        'engine (`check.ts`) only needs a new case in `evaluateRule()` when a rule',\n        'needs a genuinely new kind of check.',\n        '',\n        '## Rule shape',\n        '',\n        '```json',\n        '{',\n        '  \"id\": \"unique-id\",',\n        '  \"description\": \"What this enforces and why.\",',\n        '  \"enabled\": true,',\n        '  \"severity\": \"low\" | \"medium\" | \"high\" | \"critical\",',\n        '  \"check\": {',\n        '    \"type\": \"forbidden-import\",',\n        '    \"from\": [\"glob patterns selecting files this rule inspects\"],',\n        '    \"forbid\": [\"glob patterns those files may not import from\"]',\n        '  }',\n        '}',\n        '```',\n        '',\n        '`enabled: false` rules are skipped (reported as \"deferred\") rather than',\n        \"evaluated — use this for a rule you've named and described but don't yet\",\n        'have a concrete convention to check.',\n        '',\n        '## Current rules',\n        '',\n        'None yet — `rules.json` ships empty. Add rules as your domain module',\n        'conventions solidify (e.g. an event-sourced/CQRS module layout under',\n        '`src/domains/<name>/{commands,events,aggregates,projections}/`).',\n        '',\n        '## Adding a check type',\n        '',\n        '`forbidden-import` is the only implemented `check.type`. If a future rule',\n        'needs something it can\\'t express (e.g. \"every aggregate file must have a',\n        'matching events file\"), add a new `type` value, a matching interface, and a',\n        'case in `evaluateRule()` in `check.ts` — keep the engine itself generic;',\n        'rule-specific knowledge belongs in `rules.json`.',\n      ],\n    });\n\n    new SampleFile(project, 'architecture-rules/rules.json', {\n      contents: JSON.stringify({ rules: [] }, null, 2) + '\\n',\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SoftwareFactoryArchitectureRules.js","sourceRoot":"","sources":["../src/SoftwareFactoryArchitectureRules.ts"],"names":[],"mappings":"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","sourcesContent":["import { JsonFile, SampleFile, TextFile } from 'projen';\nimport { NodeProject } from 'projen/lib/javascript';\n\n/**\n * The generic, data-driven architecture rule engine plus an empty seed\n * rules.json. `check.ts`/`tsconfig.json`/`README.md` are managed (Batman\n * owns the engine); `rules.json` is a `SampleFile` — each repo's own rules\n * are data the team owns, not something Batman should overwrite.\n */\nexport class SoftwareFactoryArchitectureRules {\n  constructor(project: NodeProject) {\n    new TextFile(project, 'architecture-rules/check.ts', {\n      marker: true,\n      lines: [\n        '/**',\n        ' * Generic architecture-rule engine. Rules live entirely in rules.json — this',\n        ' * file only knows how to evaluate the check \"types\" that rules can declare.',\n        ' * Add a new rule by adding a rules.json entry; add a new check type by adding',\n        ' * a case in evaluateRule().',\n        ' */',\n        \"import * as fs from 'node:fs';\",\n        \"import * as path from 'node:path';\",\n        \"import { execFileSync } from 'node:child_process';\",\n        \"import rulesFile from './rules.json';\",\n        '',\n        'interface ForbiddenImportCheck {',\n        \"  type: 'forbidden-import';\",\n        '  // Glob patterns (relative to repo root) selecting the files this rule inspects.',\n        '  from: string[];',\n        '  // Glob patterns (relative to repo root) that \"from\" files may not import from.',\n        '  forbid: string[];',\n        '}',\n        '',\n        'interface RequiredCompanionCheck {',\n        \"  type: 'required-companion';\",\n        '  // Glob patterns selecting changed files that trigger the requirement.',\n        '  from: string[];',\n        '  // Glob patterns -- at least one CHANGED file must match one of these.',\n        '  requireOneOf: string[];',\n        \"  // Optional -- 'from' files matching these globs don't trigger the requirement.\",\n        '  exempt?: string[];',\n        '}',\n        '',\n        'interface Rule {',\n        '  id: string;',\n        '  description: string;',\n        '  enabled: boolean;',\n        \"  severity: 'low' | 'medium' | 'high' | 'critical';\",\n        '  check: ForbiddenImportCheck | RequiredCompanionCheck;',\n        '}',\n        '',\n        'interface Violation {',\n        '  ruleId: string;',\n        '  severity: string;',\n        '  message: string;',\n        '}',\n        '',\n        \"const REPO_ROOT = path.resolve(__dirname, '..');\",\n        \"const IGNORED_DIRS = new Set(['node_modules', '.git', '.swamp', 'cdk.out', 'lib', 'build', 'dist']);\",\n        \"const BASE_REF = process.env.ARCHITECTURE_RULES_BASE_REF || 'origin/main';\",\n        '',\n        '// Minimal glob -> RegExp: supports \"*\", \"**\", \"**/\" and literal path segments.',\n        '// No new dependency for this — the only pattern shapes rules.json ever needs',\n        '// are directory-prefix globs like \"src/domains/*/commands/**\".',\n        'function globToRegExp(glob: string): RegExp {',\n        \"  let out = '';\",\n        '  for (let i = 0; i < glob.length; i++) {',\n        '    const c = glob[i];',\n        \"    if (c === '*' && glob[i + 1] === '*') {\",\n        '      i++;',\n        \"      if (glob[i + 1] === '/') {\",\n        \"        out += '(?:.*/)?';\",\n        '        i++;',\n        '      } else {',\n        \"        out += '.*';\",\n        '      }',\n        \"    } else if (c === '*') {\",\n        \"      out += '[^/]*';\",\n        \"    } else if (c === '?') {\",\n        \"      out += '[^/]';\",\n        \"    } else if ('.+^${}()|[]\\\\\\\\'.includes(c)) {\",\n        '      out += `\\\\\\\\${c}`;',\n        '    } else {',\n        '      out += c;',\n        '    }',\n        '  }',\n        '  return new RegExp(`^${out}$`);',\n        '}',\n        '',\n        'function matchesAny(relFile: string, globs: string[]): boolean {',\n        '  return globs.some((glob) => globToRegExp(glob).test(relFile));',\n        '}',\n        '',\n        'function toRepoRelative(absPath: string): string {',\n        \"  return path.relative(REPO_ROOT, absPath).split(path.sep).join('/');\",\n        '}',\n        '',\n        '// Files changed relative to baseRef, sourced from git rather than the whole-tree',\n        '// walk() below -- required-companion checks care about what a PR touched, not',\n        '// the full repo. Throws (rather than returning []) if baseRef cannot be resolved,',\n        '// so an unfetched base ref fails the check instead of silently reporting no violations.',\n        'function getChangedFiles(baseRef: string): string[] {',\n        '  let output: string;',\n        '  try {',\n        \"    output = execFileSync('git', ['diff', '--name-only', '--diff-filter=ACMR', `${baseRef}...HEAD`], {\",\n        '      cwd: REPO_ROOT,',\n        \"      encoding: 'utf8',\",\n        '    });',\n        '  } catch (err) {',\n        '    throw new Error(',\n        '      `architecture-rules: failed to compute the changed-file set against base ref \"${baseRef}\" -- ` +',\n        '        `is it fetched and resolvable in this checkout? (${(err as Error).message})`,',\n        '    );',\n        '  }',\n        \"  return output.split('\\\\n').map((line) => line.trim()).filter((line) => line.length > 0);\",\n        '}',\n        '',\n        'function walk(dir: string, acc: string[] = []): string[] {',\n        '  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {',\n        '    if (IGNORED_DIRS.has(entry.name)) continue;',\n        '    const full = path.join(dir, entry.name);',\n        '    if (entry.isDirectory()) {',\n        '      walk(full, acc);',\n        \"    } else if (entry.isFile() && (entry.name.endsWith('.ts') || entry.name.endsWith('.tsx'))) {\",\n        '      acc.push(full);',\n        '    }',\n        '  }',\n        '  return acc;',\n        '}',\n        '',\n        \"const RELATIVE_IMPORT_RE = /(?:import|export)\\\\s+(?:[^'\\\";]*?\\\\bfrom\\\\s+)?['\\\"](\\\\.[^'\\\"]+)['\\\"]/g;\",\n        '',\n        'function findRelativeImports(source: string): string[] {',\n        '  const specs: string[] = [];',\n        '  RELATIVE_IMPORT_RE.lastIndex = 0;',\n        '  let match: RegExpExecArray | null;',\n        '  while ((match = RELATIVE_IMPORT_RE.exec(source))) {',\n        '    specs.push(match[1]);',\n        '  }',\n        '  return specs;',\n        '}',\n        '',\n        '// An import spec resolves to a module, not a specific file extension, so a',\n        '// forbid glob is checked against the bare resolved path plus its .ts/index.ts',\n        '// variants.',\n        'function resolvedCandidates(fromFile: string, spec: string): string[] {',\n        '  const resolved = toRepoRelative(path.normalize(path.join(path.dirname(fromFile), spec)));',\n        '  return [resolved, `${resolved}.ts`, `${resolved}/index.ts`];',\n        '}',\n        '',\n        'function evaluateForbiddenImport(rule: Rule): Violation[] {',\n        '  const { from, forbid } = rule.check as ForbiddenImportCheck;',\n        '  if (from.length === 0 || forbid.length === 0) return [];',\n        '',\n        '  const violations: Violation[] = [];',\n        '  for (const file of walk(REPO_ROOT)) {',\n        '    const relFile = toRepoRelative(file);',\n        '    if (!matchesAny(relFile, from)) continue;',\n        '',\n        \"    const source = fs.readFileSync(file, 'utf8');\",\n        '    for (const spec of findRelativeImports(source)) {',\n        '      const candidates = resolvedCandidates(file, spec);',\n        '      if (candidates.some((candidate) => matchesAny(candidate, forbid))) {',\n        '        violations.push({',\n        '          ruleId: rule.id,',\n        '          severity: rule.severity,',\n        '          message: `${relFile} imports \"${spec}\", which resolves under a path forbidden by rule \"${rule.id}\"`,',\n        '        });',\n        '      }',\n        '    }',\n        '  }',\n        '  return violations;',\n        '}',\n        '',\n        'function evaluateRequiredCompanion(rule: Rule): Violation[] {',\n        '  const { from, requireOneOf, exempt } = rule.check as RequiredCompanionCheck;',\n        '  if (from.length === 0 || requireOneOf.length === 0) return [];',\n        '',\n        '  const changedFiles = getChangedFiles(BASE_REF);',\n        '  const triggering = changedFiles.filter(',\n        '    (file) => matchesAny(file, from) && !(exempt && matchesAny(file, exempt)),',\n        '  );',\n        '  if (triggering.length === 0) return [];',\n        '',\n        '  const satisfied = changedFiles.some((file) => matchesAny(file, requireOneOf));',\n        '  if (satisfied) return [];',\n        '',\n        '  return [',\n        '    {',\n        '      ruleId: rule.id,',\n        '      severity: rule.severity,',\n        '      message: `changed file(s) ${triggering.join(\\', \\')} match rule \"${rule.id}\"\\'s \"from\" patterns, but no changed file matches its \"requireOneOf\" patterns`,',\n        '    },',\n        '  ];',\n        '}',\n        '',\n        'function evaluateRule(rule: Rule): Violation[] {',\n        '  switch (rule.check.type) {',\n        \"    case 'forbidden-import':\",\n        '      return evaluateForbiddenImport(rule);',\n        \"    case 'required-companion':\",\n        '      return evaluateRequiredCompanion(rule);',\n        '    default:',\n        '      throw new Error(`architecture-rules: unknown check.type \"${(rule.check as { type: string }).type}\" on rule \"${rule.id}\"`);',\n        '  }',\n        '}',\n        '',\n        'function main(): number {',\n        '  const rules = (rulesFile as { rules: Rule[] }).rules;',\n        '  let evaluated = 0;',\n        '  let deferred = 0;',\n        '  const violations: Violation[] = [];',\n        '',\n        '  for (const rule of rules) {',\n        '    if (!rule.enabled) {',\n        '      deferred++;',\n        '      console.log(`[deferred] ${rule.id}: ${rule.description}`);',\n        '      continue;',\n        '    }',\n        '    evaluated++;',\n        '    violations.push(...evaluateRule(rule));',\n        '  }',\n        '',\n        '  console.log(`\\\\narchitecture-rules: ${evaluated} rule(s) evaluated, ${deferred} deferred, ${violations.length} violation(s)`);',\n        '  for (const violation of violations) {',\n        '    console.error(`  [${violation.severity}] ${violation.ruleId}: ${violation.message}`);',\n        '  }',\n        '',\n        '  return violations.length > 0 ? 1 : 0;',\n        '}',\n        '',\n        'process.exit(main());',\n      ],\n    });\n\n    new JsonFile(project, 'architecture-rules/tsconfig.json', {\n      marker: false,\n      obj: {\n        extends: '../tsconfig.json',\n        compilerOptions: {\n          noEmit: true,\n          rootDir: '.',\n        },\n        include: ['*.ts', '*.json'],\n        exclude: ['node_modules'],\n      },\n    });\n\n    new TextFile(project, 'architecture-rules/README.md', {\n      marker: true,\n      lines: [\n        '# Architecture rules',\n        '',\n        'A data-driven registry of architectural constraints, enforced by',\n        '`pnpm validate:architecture` and run as part of the pre-PR verification',\n        'workflow (`workflows/workflow-pre-pr-verify.yaml`) before the swamp factory',\n        'opens a PR. New rules are new entries in `rules.json`, not new code — the',\n        'engine (`check.ts`) only needs a new case in `evaluateRule()` when a rule',\n        'needs a genuinely new kind of check.',\n        '',\n        '## Rule shape',\n        '',\n        'Two `check.type`s are implemented: `forbidden-import` (whole-repo import-graph',\n        'check) and `required-companion` (diff-based co-change check).',\n        '',\n        '```json',\n        '{',\n        '  \"id\": \"unique-id\",',\n        '  \"description\": \"What this enforces and why.\",',\n        '  \"enabled\": true,',\n        '  \"severity\": \"low\" | \"medium\" | \"high\" | \"critical\",',\n        '  \"check\": {',\n        '    \"type\": \"forbidden-import\",',\n        '    \"from\": [\"glob patterns selecting files this rule inspects\"],',\n        '    \"forbid\": [\"glob patterns those files may not import from\"]',\n        '  }',\n        '}',\n        '```',\n        '',\n        '```json',\n        '{',\n        '  \"id\": \"unique-id\",',\n        '  \"description\": \"What this enforces and why.\",',\n        '  \"enabled\": true,',\n        '  \"severity\": \"low\" | \"medium\" | \"high\" | \"critical\",',\n        '  \"check\": {',\n        '    \"type\": \"required-companion\",',\n        '    \"from\": [\"glob patterns selecting changed files that trigger the requirement\"],',\n        '    \"requireOneOf\": [\"glob patterns -- at least one CHANGED file must match one of these\"],',\n        '    \"exempt\": [\"optional -- from-files matching these globs don\\'t trigger the requirement\"]',\n        '  }',\n        '}',\n        '```',\n        '',\n        '`required-companion` evaluates the set of files changed in the current diff',\n        '(`git diff --name-only --diff-filter=ACMR <baseRef>...HEAD`), not the whole',\n        'repo tree: if any changed file matches `from` (and doesn\\'t match `exempt`) but',\n        'no changed file matches `requireOneOf`, that\\'s a violation. The base ref',\n        'defaults to `origin/main` and can be overridden with the',\n        '`ARCHITECTURE_RULES_BASE_REF` environment variable. This means the checkout',\n        'running `pnpm validate:architecture` must have that base ref fetched and',\n        'resolvable (a shallow, single-branch checkout will make the check fail closed',\n        'with an error rather than silently reporting no violations) — make sure',\n        'whatever runs this task fetches enough history for `git diff <baseRef>...HEAD`',\n        'to succeed.',\n        '',\n        '`from`/`requireOneOf`/`exempt` globs are matched against the paths `git',\n        'diff --name-only` reports, which are relative to the git repository\\'s',\n        'top-level directory. This lines up with `from`\\'s own directory (the parent of',\n        '`architecture-rules/`) in the common case — a single project generated at the',\n        'repo root — but if `architecture-rules/` instead lives under a nested',\n        'subdirectory of a larger git repo, write globs relative to the git root, not',\n        'to that subdirectory.',\n        '',\n        '**`required-companion` is a coverage check, not a correctness check.** It only',\n        'confirms that *some* changed file matches `requireOneOf` — it can\\'t tell',\n        'whether that change is actually related to the triggering `from` change (a',\n        'trivial or unrelated edit to a file under `requireOneOf` satisfies the rule',\n        'just as well as a substantive one), and it can\\'t tell whether a given `from`',\n        'change genuinely needed a companion at all (a pure refactor might not).',\n        '`exempt` covers *known, glob-expressible* exceptions, but not every false',\n        'positive is expressible as a glob — that judgment call still belongs to the',\n        'rule author (scoping `from`/`exempt`) and the reviewer (reading the companion',\n        'diff, not just trusting that the check passed). Also note that `main()`',\n        'fails the whole run on *any* violation regardless of `severity` — `severity`',\n        'is informational only, not a leniency lever — so start with a narrowly',\n        'scoped `from` (or `enabled: false`) and widen it as the convention proves',\n        'itself, the same guidance as for `forbidden-import`.',\n        '',\n        '`enabled: false` rules are skipped (reported as \"deferred\") rather than',\n        \"evaluated — use this for a rule you've named and described but don't yet\",\n        'have a concrete convention to check.',\n        '',\n        '## Current rules',\n        '',\n        'None yet — `rules.json` ships empty. Add rules as your domain module',\n        'conventions solidify (e.g. an event-sourced/CQRS module layout under',\n        '`src/domains/<name>/{commands,events,aggregates,projections}/`).',\n        '',\n        '## Adding a check type',\n        '',\n        '`forbidden-import` (whole-repo import graph) and `required-companion`',\n        '(diff-based co-change) are the implemented `check.type`s. If a future rule',\n        'needs a data source neither provides (e.g. \"every aggregate file must have a',\n        'matching events file\", which is a repo-wide naming convention rather than',\n        'either an import-graph or a diff check), add a new `type` value, a matching',\n        'interface, and a case in `evaluateRule()` in `check.ts` — keep the engine',\n        'itself generic; rule-specific knowledge belongs in `rules.json`.',\n      ],\n    });\n\n    new SampleFile(project, 'architecture-rules/rules.json', {\n      contents: JSON.stringify({ rules: [] }, null, 2) + '\\n',\n    });\n  }\n}\n"]}

package/lib/SoftwareFactoryFiles.js

@@ -31,7 +31,7 @@ const DEFAULT_GITHUB_OWNER = 'macedon-technologies';
  * workflows that wire them together) is templated.
  */
 class SoftwareFactoryFiles {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.SoftwareFactoryFiles", version: "1.24.2" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.SoftwareFactoryFiles", version: "1.25.0" };
     constructor(project, options) {
         const { repoName, actionVersions } = options;
         const githubOwner = options.githubOwner || DEFAULT_GITHUB_OWNER;

package/lib/StagingDeployWorkflow.js

@@ -7,7 +7,7 @@ const javascript_1 = require("projen/lib/javascript");
 const utils_1 = require("./utils");
 const WorkflowActionVersions_1 = require("./WorkflowActionVersions");
 class StagingDeployWorkflow extends projen_1.YamlFile {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.StagingDeployWorkflow", version: "1.24.2" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.StagingDeployWorkflow", version: "1.25.0" };
     constructor(project, options) {
         const packageManager = project.package.packageManager;
         const actionVersions = (0, WorkflowActionVersions_1.resolveActionVersions)(options.actionVersions);

package/lib/WorkflowAutoDiscover.js

@@ -39,7 +39,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const projen_1 = require("projen");
 class WorkflowAutoDiscover extends projen_1.Component {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.WorkflowAutoDiscover", version: "1.24.2" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.WorkflowAutoDiscover", version: "1.25.0" };
     constructor(project) {
         super(project);
     }

package/package.json

@@ -49,7 +49,7 @@
   "main": "lib/index.js",
   "license": "Apache-2.0",
   "stability": "stable",
-  "version": "1.24.2",
+  "version": "1.25.0",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [