@macedon-technologies/batman 1.17.2 → 1.18.0

package/lib/BootcampProject.js

@@ -8,10 +8,11 @@ const BootcampApplication_1 = require("./BootcampApplication");
 const CodeOwnersFile_1 = require("./CodeOwnersFile");
 const DataDogAspectFile_1 = require("./DataDogAspectFile");
 const GitHubRolesFile_1 = require("./GitHubRolesFile");
+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.17.2" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.BootcampProject", version: "1.18.0" };
     constructor(options) {
         super({
             ...options,
@@ -96,6 +97,11 @@ class BootcampProject extends awscdk_1.AwsCdkTypeScriptApp {
             additionalOwners: options.additionalCodeOwners,
         });
         new DataDogAspectFile_1.DataDogAspectFile(this);
+        new SoftwareFactoryFiles_1.SoftwareFactoryFiles(this, {
+            repoName: options.name,
+            baseBranch: options.defaultReleaseBranch,
+            actionVersions: options.actionVersions,
+        });
         const viteReact = new ViteReactProject_1.ViteReactProject({
             name: options.name,
             defaultReleaseBranch: 'main',
@@ -118,4 +124,4 @@ class BootcampProject extends awscdk_1.AwsCdkTypeScriptApp {
     }
 }
 exports.BootcampProject = BootcampProject;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BootcampProject.js","sourceRoot":"","sources":["../src/BootcampProject.ts"],"names":[],"mappings":"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","sourcesContent":["import { AwsCdkTypeScriptApp } from 'projen/lib/awscdk';\nimport { GithubCredentials } from 'projen/lib/github';\nimport { BatmanProjectOptions } from './BatmanProject';\nimport { BootcampApplication } from './BootcampApplication';\nimport { CodeOwnersFile } from './CodeOwnersFile';\nimport { DataDogAspectFile } from './DataDogAspectFile';\nimport { GitHubRolesFile } from './GitHubRolesFile';\nimport { readmeContents } from './utils';\nimport { ViteReactProject } from './ViteReactProject';\n\n\nexport interface BootcampProjectOptions extends BatmanProjectOptions {\n\n}\n\nexport class BootcampProject extends AwsCdkTypeScriptApp {\n  constructor(options: BootcampProjectOptions) {\n    super({\n      ...options,\n      cdkVersion: options.cdkVersion || '2.224.0',\n      defaultReleaseBranch: options.defaultReleaseBranch || 'main',\n      name: options.name,\n      projenrcTs: true,\n      buildWorkflow: false,\n      deps: [\n        '@types/aws-lambda',\n        '@types/express',\n        '@types/pg',\n        'pg',\n        '@aws-sdk/rds-signer',\n        '@matthewbonig/secret',\n        'datadog-cdk-constructs-v2',\n        '@cdklabs/aws-lambda-rust',\n        '@aws-lambda-powertools/parameters',\n        'jsonwebtoken',\n        '@aws-sdk/client-secrets-manager',\n        'express',\n        'serverless-http',\n        'cdk-rds-sql',\n        ...options.deps || [],\n      ],\n      devDeps: [\n        '@types/jsonwebtoken',\n        'nodemon',\n        'concurrently',\n        '@macedon-technologies/batman@^1.0.0',\n        ...options.devDeps || [],\n      ],\n      gitignore: [\n        'src/constructs/handler/clerk-authorizer/target/**',\n        '**/.DS_Store',\n        ...options.gitignore || [],\n      ],\n      tsconfig: {\n        ...options.tsconfig,\n        compilerOptions: {\n          ...options.tsconfig?.compilerOptions,\n          isolatedModules: true,\n          allowImportingTsExtensions: true,\n        },\n      },\n      sampleCode: false,\n      minNodeVersion: options.minNodeVersion || '22',\n      depsUpgradeOptions: {\n        workflowOptions: {\n          projenCredentials: GithubCredentials.fromPersonalAccessToken({\n            secret: 'GITHUB_TOKEN',\n          }),\n        },\n      },\n      readme: {\n        contents: readmeContents(options.name),\n      },\n    });\n\n\n    // Create standard project files\n    const PRIMARY_ACCOUNT = '015955817263';\n    const PRIMARY_REGION = 'us-east-1';\n\n    new BootcampApplication(this, {\n      githubRepository: `macedon-technologies/${options.name}`,\n      dev: {\n        ...options.dev,\n      },\n      staging: {\n        ...options.staging,\n      },\n      prod: {\n        ...options.dev,\n      },\n      additionalTags: options.additionalTags,\n      n8nWorkflows: options.n8nWorkflows,\n      actionVersions: options.actionVersions,\n    });\n\n    new GitHubRolesFile(this, {\n      account: PRIMARY_ACCOUNT,\n      primaryRegion: PRIMARY_REGION,\n    });\n\n    new CodeOwnersFile(this, {\n      additionalOwners: options.additionalCodeOwners,\n    });\n\n    new DataDogAspectFile(this);\n\n    const viteReact = new ViteReactProject({\n      name: options.name,\n      defaultReleaseBranch: 'main',\n      parent: this,\n      outdir: 'web',\n      deps: options.websiteDeps,\n    });\n    viteReact.addConfigField('something', 'number');\n    viteReact.addConfigField('somethingElse', 'string');\n\n    const concurrently = (...args: string[]) => {\n      return `concurrently ${args.map(a => `\"${a}\"`).join(' ')}`;\n    };\n\n    this.addTask('dev', {\n      exec: concurrently(\n        'nodemon --watch ./src/constructs/handler --watch ./local/dev.ts ./local/dev.ts',\n        viteReact.devCommand,\n      ),\n    });\n\n    this.addTask('cdk:dev', {\n      exec: 'cdk -a \"npx ts-node -P tsconfig.json --prefer-ts-exts src/LocalDevApp.ts\"',\n      receiveArgs: true,\n    });\n\n\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BootcampProject.js","sourceRoot":"","sources":["../src/BootcampProject.ts"],"names":[],"mappings":"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","sourcesContent":["import { AwsCdkTypeScriptApp } from 'projen/lib/awscdk';\nimport { GithubCredentials } from 'projen/lib/github';\nimport { BatmanProjectOptions } from './BatmanProject';\nimport { BootcampApplication } from './BootcampApplication';\nimport { CodeOwnersFile } from './CodeOwnersFile';\nimport { DataDogAspectFile } from './DataDogAspectFile';\nimport { GitHubRolesFile } from './GitHubRolesFile';\nimport { SoftwareFactoryFiles } from './SoftwareFactoryFiles';\nimport { readmeContents } from './utils';\nimport { ViteReactProject } from './ViteReactProject';\n\n\nexport interface BootcampProjectOptions extends BatmanProjectOptions {\n\n}\n\nexport class BootcampProject extends AwsCdkTypeScriptApp {\n  constructor(options: BootcampProjectOptions) {\n    super({\n      ...options,\n      cdkVersion: options.cdkVersion || '2.224.0',\n      defaultReleaseBranch: options.defaultReleaseBranch || 'main',\n      name: options.name,\n      projenrcTs: true,\n      buildWorkflow: false,\n      deps: [\n        '@types/aws-lambda',\n        '@types/express',\n        '@types/pg',\n        'pg',\n        '@aws-sdk/rds-signer',\n        '@matthewbonig/secret',\n        'datadog-cdk-constructs-v2',\n        '@cdklabs/aws-lambda-rust',\n        '@aws-lambda-powertools/parameters',\n        'jsonwebtoken',\n        '@aws-sdk/client-secrets-manager',\n        'express',\n        'serverless-http',\n        'cdk-rds-sql',\n        ...options.deps || [],\n      ],\n      devDeps: [\n        '@types/jsonwebtoken',\n        'nodemon',\n        'concurrently',\n        '@macedon-technologies/batman@^1.0.0',\n        ...options.devDeps || [],\n      ],\n      gitignore: [\n        'src/constructs/handler/clerk-authorizer/target/**',\n        '**/.DS_Store',\n        ...options.gitignore || [],\n      ],\n      tsconfig: {\n        ...options.tsconfig,\n        compilerOptions: {\n          ...options.tsconfig?.compilerOptions,\n          isolatedModules: true,\n          allowImportingTsExtensions: true,\n        },\n      },\n      sampleCode: false,\n      minNodeVersion: options.minNodeVersion || '22',\n      depsUpgradeOptions: {\n        workflowOptions: {\n          projenCredentials: GithubCredentials.fromPersonalAccessToken({\n            secret: 'GITHUB_TOKEN',\n          }),\n        },\n      },\n      readme: {\n        contents: readmeContents(options.name),\n      },\n    });\n\n\n    // Create standard project files\n    const PRIMARY_ACCOUNT = '015955817263';\n    const PRIMARY_REGION = 'us-east-1';\n\n    new BootcampApplication(this, {\n      githubRepository: `macedon-technologies/${options.name}`,\n      dev: {\n        ...options.dev,\n      },\n      staging: {\n        ...options.staging,\n      },\n      prod: {\n        ...options.dev,\n      },\n      additionalTags: options.additionalTags,\n      n8nWorkflows: options.n8nWorkflows,\n      actionVersions: options.actionVersions,\n    });\n\n    new GitHubRolesFile(this, {\n      account: PRIMARY_ACCOUNT,\n      primaryRegion: PRIMARY_REGION,\n    });\n\n    new CodeOwnersFile(this, {\n      additionalOwners: options.additionalCodeOwners,\n    });\n\n    new DataDogAspectFile(this);\n\n    new SoftwareFactoryFiles(this, {\n      repoName: options.name,\n      baseBranch: options.defaultReleaseBranch,\n      actionVersions: options.actionVersions,\n    });\n\n    const viteReact = new ViteReactProject({\n      name: options.name,\n      defaultReleaseBranch: 'main',\n      parent: this,\n      outdir: 'web',\n      deps: options.websiteDeps,\n    });\n    viteReact.addConfigField('something', 'number');\n    viteReact.addConfigField('somethingElse', 'string');\n\n    const concurrently = (...args: string[]) => {\n      return `concurrently ${args.map(a => `\"${a}\"`).join(' ')}`;\n    };\n\n    this.addTask('dev', {\n      exec: concurrently(\n        'nodemon --watch ./src/constructs/handler --watch ./local/dev.ts ./local/dev.ts',\n        viteReact.devCommand,\n      ),\n    });\n\n    this.addTask('cdk:dev', {\n      exec: 'cdk -a \"npx ts-node -P tsconfig.json --prefer-ts-exts src/LocalDevApp.ts\"',\n      receiveArgs: true,\n    });\n\n\n  }\n}\n"]}

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.17.2" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.CodeOwnersFile", version: "1.18.0" };
     constructor(project, options = {}) {
         const defaultOwners = ['* @macedon-technologies/platform'];
         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.17.2" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.ProductionDeployWorkflow", version: "1.18.0" };
     constructor(project, options) {
         const packageManager = project.package.packageManager;
         const actionVersions = (0, WorkflowActionVersions_1.resolveActionVersions)(options.actionVersions);

package/lib/ProjenWorkflowHardening.d.ts

@@ -0,0 +1,18 @@
+import { AwsCdkTypeScriptApp } from 'projen/lib/awscdk';
+import { WorkflowActionVersions } from './WorkflowActionVersions';
+/**
+ * Hardens the GitHub Actions workflows that `AwsCdkTypeScriptApp` generates on its own
+ * (`upgrade.yml`, `pull-request-lint.yml`, ...) against the zizmor findings raised on
+ * consumer repos (e.g. macedon-technologies/exman#13).
+ *
+ * These workflows aren't hand-authored by this package the way `PrDeployWorkflow`/
+ * `PrCleanupWorkflow`/etc. are, so they can't be pinned by writing a literal SHA into a
+ * `uses:` string. projen exposes `project.github.actions` for exactly this case: every
+ * `uses:` rendered by a `GithubWorkflow`/`Job` (including projen's own built-in
+ * components) is resolved through it at synthesis time.
+ *
+ * `persist-credentials` and the `pull_request_target` trigger aren't covered by that
+ * registry (it only rewrites `uses:`), so those are corrected with a `JsonPatch` against
+ * the synthesized workflow file instead.
+ */
+export declare function hardenProjenGeneratedWorkflows(project: AwsCdkTypeScriptApp, actionVersions?: WorkflowActionVersions): void;

package/lib/ProjenWorkflowHardening.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hardenProjenGeneratedWorkflows = hardenProjenGeneratedWorkflows;
+const projen_1 = require("projen");
+const WorkflowActionVersions_1 = require("./WorkflowActionVersions");
+/**
+ * Hardens the GitHub Actions workflows that `AwsCdkTypeScriptApp` generates on its own
+ * (`upgrade.yml`, `pull-request-lint.yml`, ...) against the zizmor findings raised on
+ * consumer repos (e.g. macedon-technologies/exman#13).
+ *
+ * These workflows aren't hand-authored by this package the way `PrDeployWorkflow`/
+ * `PrCleanupWorkflow`/etc. are, so they can't be pinned by writing a literal SHA into a
+ * `uses:` string. projen exposes `project.github.actions` for exactly this case: every
+ * `uses:` rendered by a `GithubWorkflow`/`Job` (including projen's own built-in
+ * components) is resolved through it at synthesis time.
+ *
+ * `persist-credentials` and the `pull_request_target` trigger aren't covered by that
+ * registry (it only rewrites `uses:`), so those are corrected with a `JsonPatch` against
+ * the synthesized workflow file instead.
+ */
+function hardenProjenGeneratedWorkflows(project, actionVersions) {
+    const versions = (0, WorkflowActionVersions_1.resolveActionVersions)(actionVersions);
+    const github = project.github;
+    if (!github) {
+        return;
+    }
+    // zizmor: unpinned-uses (high) — projen's built-in workflows reference these actions by
+    // mutable tag (e.g. `actions/checkout@v6`). Overriding by bare action name repoints every
+    // usage projen renders, without touching the hand-authored workflows above (which already
+    // embed a resolved SHA literal and never go through this registry). upload-artifact,
+    // download-artifact and action-semantic-pull-request weren't reported in #13, but are the
+    // same finding on the same two files, so they're pinned here too rather than left ticking.
+    github.actions.set('actions/checkout', versions.checkout);
+    github.actions.set('actions/setup-node', versions.setupNode);
+    github.actions.set('pnpm/action-setup', versions.pnpmActionSetup);
+    github.actions.set('actions/github-script', versions.githubScript);
+    github.actions.set('peter-evans/create-pull-request', versions.createPullRequest);
+    github.actions.set('actions/upload-artifact', versions.uploadArtifact);
+    github.actions.set('actions/download-artifact', versions.downloadArtifact);
+    github.actions.set('amannn/action-semantic-pull-request', versions.semanticPullRequest);
+    // zizmor: artipacked (low) — actions/checkout persists git credentials to disk by
+    // default. Neither of upgrade.yml's checkout steps need to push from that checkout
+    // (the "pr" job's push happens via peter-evans/create-pull-request with its own token).
+    const upgrade = github.tryFindWorkflow('upgrade');
+    upgrade?.file?.patch(projen_1.JsonPatch.add('/jobs/upgrade/steps/0/with', { 'persist-credentials': false }), projen_1.JsonPatch.add('/jobs/pr/steps/0/with', { 'persist-credentials': false }));
+    // zizmor: dangerous-triggers (high) — pull-request-lint.yml only validates the PR title;
+    // it doesn't need pull_request_target's access to secrets/write permissions against
+    // untrusted fork content. `pull_request` covers the same title-changed events without
+    // the risk. (If a consumer ever needs this check to comment on forked PRs, that consumer
+    // should override `pullRequestLintOptions` accordingly instead of reverting this globally.)
+    const pullRequestLint = github.tryFindWorkflow('pull-request-lint');
+    pullRequestLint?.file?.patch(projen_1.JsonPatch.replace('/on', {
+        pull_request: {
+            types: ['labeled', 'opened', 'synchronize', 'reopened', 'ready_for_review', 'edited'],
+        },
+        merge_group: {},
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/SoftwareFactoryArchitectureRules.d.ts

@@ -0,0 +1,10 @@
+import { NodeProject } from 'projen/lib/javascript';
+/**
+ * The generic, data-driven architecture rule engine plus an empty seed
+ * rules.json. `check.ts`/`tsconfig.json`/`README.md` are managed (Batman
+ * owns the engine); `rules.json` is a `SampleFile` — each repo's own rules
+ * are data the team owns, not something Batman should overwrite.
+ */
+export declare class SoftwareFactoryArchitectureRules {
+    constructor(project: NodeProject);
+}

package/lib/SoftwareFactoryArchitectureRules.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoftwareFactoryArchitectureRules = void 0;
+const projen_1 = require("projen");
+/**
+ * The generic, data-driven architecture rule engine plus an empty seed
+ * rules.json. `check.ts`/`tsconfig.json`/`README.md` are managed (Batman
+ * owns the engine); `rules.json` is a `SampleFile` — each repo's own rules
+ * are data the team owns, not something Batman should overwrite.
+ */
+class SoftwareFactoryArchitectureRules {
+    constructor(project) {
+        new projen_1.TextFile(project, 'architecture-rules/check.ts', {
+            marker: true,
+            lines: [
+                '/**',
+                ' * Generic architecture-rule engine. Rules live entirely in rules.json — this',
+                ' * file only knows how to evaluate the check "types" that rules can declare.',
+                ' * Add a new rule by adding a rules.json entry; add a new check type by adding',
+                ' * a case in evaluateRule().',
+                ' */',
+                "import * as fs from 'node:fs';",
+                "import * as path from 'node:path';",
+                "import rulesFile from './rules.json';",
+                '',
+                'interface ForbiddenImportCheck {',
+                "  type: 'forbidden-import';",
+                '  // Glob patterns (relative to repo root) selecting the files this rule inspects.',
+                '  from: string[];',
+                '  // Glob patterns (relative to repo root) that "from" files may not import from.',
+                '  forbid: string[];',
+                '}',
+                '',
+                'interface Rule {',
+                '  id: string;',
+                '  description: string;',
+                '  enabled: boolean;',
+                "  severity: 'low' | 'medium' | 'high' | 'critical';",
+                '  check: ForbiddenImportCheck;',
+                '}',
+                '',
+                'interface Violation {',
+                '  ruleId: string;',
+                '  severity: string;',
+                '  message: string;',
+                '}',
+                '',
+                "const REPO_ROOT = path.resolve(__dirname, '..');",
+                "const IGNORED_DIRS = new Set(['node_modules', '.git', '.swamp', 'cdk.out', 'lib', 'build', 'dist']);",
+                '',
+                '// Minimal glob -> RegExp: supports "*", "**", "**/" and literal path segments.',
+                '// No new dependency for this — the only pattern shapes rules.json ever needs',
+                '// are directory-prefix globs like "src/domains/*/commands/**".',
+                'function globToRegExp(glob: string): RegExp {',
+                "  let out = '';",
+                '  for (let i = 0; i < glob.length; i++) {',
+                '    const c = glob[i];',
+                "    if (c === '*' && glob[i + 1] === '*') {",
+                '      i++;',
+                "      if (glob[i + 1] === '/') {",
+                "        out += '(?:.*/)?';",
+                '        i++;',
+                '      } else {',
+                "        out += '.*';",
+                '      }',
+                "    } else if (c === '*') {",
+                "      out += '[^/]*';",
+                "    } else if (c === '?') {",
+                "      out += '[^/]';",
+                "    } else if ('.+^${}()|[]\\\\'.includes(c)) {",
+                '      out += `\\\\${c}`;',
+                '    } else {',
+                '      out += c;',
+                '    }',
+                '  }',
+                '  return new RegExp(`^${out}$`);',
+                '}',
+                '',
+                'function matchesAny(relFile: string, globs: string[]): boolean {',
+                '  return globs.some((glob) => globToRegExp(glob).test(relFile));',
+                '}',
+                '',
+                'function toRepoRelative(absPath: string): string {',
+                "  return path.relative(REPO_ROOT, absPath).split(path.sep).join('/');",
+                '}',
+                '',
+                'function walk(dir: string, acc: string[] = []): string[] {',
+                '  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {',
+                '    if (IGNORED_DIRS.has(entry.name)) continue;',
+                '    const full = path.join(dir, entry.name);',
+                '    if (entry.isDirectory()) {',
+                '      walk(full, acc);',
+                "    } else if (entry.isFile() && (entry.name.endsWith('.ts') || entry.name.endsWith('.tsx'))) {",
+                '      acc.push(full);',
+                '    }',
+                '  }',
+                '  return acc;',
+                '}',
+                '',
+                "const RELATIVE_IMPORT_RE = /(?:import|export)\\s+(?:[^'\";]*?\\bfrom\\s+)?['\"](\\.[^'\"]+)['\"]/g;",
+                '',
+                'function findRelativeImports(source: string): string[] {',
+                '  const specs: string[] = [];',
+                '  RELATIVE_IMPORT_RE.lastIndex = 0;',
+                '  let match: RegExpExecArray | null;',
+                '  while ((match = RELATIVE_IMPORT_RE.exec(source))) {',
+                '    specs.push(match[1]);',
+                '  }',
+                '  return specs;',
+                '}',
+                '',
+                '// An import spec resolves to a module, not a specific file extension, so a',
+                '// forbid glob is checked against the bare resolved path plus its .ts/index.ts',
+                '// variants.',
+                'function resolvedCandidates(fromFile: string, spec: string): string[] {',
+                '  const resolved = toRepoRelative(path.normalize(path.join(path.dirname(fromFile), spec)));',
+                '  return [resolved, `${resolved}.ts`, `${resolved}/index.ts`];',
+                '}',
+                '',
+                'function evaluateForbiddenImport(rule: Rule): Violation[] {',
+                '  const { from, forbid } = rule.check;',
+                '  if (from.length === 0 || forbid.length === 0) return [];',
+                '',
+                '  const violations: Violation[] = [];',
+                '  for (const file of walk(REPO_ROOT)) {',
+                '    const relFile = toRepoRelative(file);',
+                '    if (!matchesAny(relFile, from)) continue;',
+                '',
+                "    const source = fs.readFileSync(file, 'utf8');",
+                '    for (const spec of findRelativeImports(source)) {',
+                '      const candidates = resolvedCandidates(file, spec);',
+                '      if (candidates.some((candidate) => matchesAny(candidate, forbid))) {',
+                '        violations.push({',
+                '          ruleId: rule.id,',
+                '          severity: rule.severity,',
+                '          message: `${relFile} imports "${spec}", which resolves under a path forbidden by rule "${rule.id}"`,',
+                '        });',
+                '      }',
+                '    }',
+                '  }',
+                '  return violations;',
+                '}',
+                '',
+                'function evaluateRule(rule: Rule): Violation[] {',
+                '  switch (rule.check.type) {',
+                "    case 'forbidden-import':",
+                '      return evaluateForbiddenImport(rule);',
+                '    default:',
+                '      throw new Error(`architecture-rules: unknown check.type "${(rule.check as { type: string }).type}" on rule "${rule.id}"`);',
+                '  }',
+                '}',
+                '',
+                'function main(): number {',
+                '  const rules = (rulesFile as { rules: Rule[] }).rules;',
+                '  let evaluated = 0;',
+                '  let deferred = 0;',
+                '  const violations: Violation[] = [];',
+                '',
+                '  for (const rule of rules) {',
+                '    if (!rule.enabled) {',
+                '      deferred++;',
+                '      console.log(`[deferred] ${rule.id}: ${rule.description}`);',
+                '      continue;',
+                '    }',
+                '    evaluated++;',
+                '    violations.push(...evaluateRule(rule));',
+                '  }',
+                '',
+                '  console.log(`\\narchitecture-rules: ${evaluated} rule(s) evaluated, ${deferred} deferred, ${violations.length} violation(s)`);',
+                '  for (const violation of violations) {',
+                '    console.error(`  [${violation.severity}] ${violation.ruleId}: ${violation.message}`);',
+                '  }',
+                '',
+                '  return violations.length > 0 ? 1 : 0;',
+                '}',
+                '',
+                'process.exit(main());',
+            ],
+        });
+        new projen_1.JsonFile(project, 'architecture-rules/tsconfig.json', {
+            marker: false,
+            obj: {
+                extends: '../tsconfig.json',
+                compilerOptions: {
+                    noEmit: true,
+                    rootDir: '.',
+                },
+                include: ['*.ts', '*.json'],
+                exclude: ['node_modules'],
+            },
+        });
+        new projen_1.TextFile(project, 'architecture-rules/README.md', {
+            marker: true,
+            lines: [
+                '# Architecture rules',
+                '',
+                'A data-driven registry of architectural constraints, enforced by',
+                '`pnpm validate:architecture` and run as part of the pre-PR verification',
+                'workflow (`workflows/workflow-pre-pr-verify.yaml`) before the swamp factory',
+                'opens a PR. New rules are new entries in `rules.json`, not new code — the',
+                'engine (`check.ts`) only needs a new case in `evaluateRule()` when a rule',
+                'needs a genuinely new kind of check.',
+                '',
+                '## Rule shape',
+                '',
+                '```json',
+                '{',
+                '  "id": "unique-id",',
+                '  "description": "What this enforces and why.",',
+                '  "enabled": true,',
+                '  "severity": "low" | "medium" | "high" | "critical",',
+                '  "check": {',
+                '    "type": "forbidden-import",',
+                '    "from": ["glob patterns selecting files this rule inspects"],',
+                '    "forbid": ["glob patterns those files may not import from"]',
+                '  }',
+                '}',
+                '```',
+                '',
+                '`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.',
+                '',
+                '## Current rules',
+                '',
+                'None yet — `rules.json` ships empty. Add rules as your domain module',
+                'conventions solidify (e.g. an event-sourced/CQRS module layout under',
+                '`src/domains/<name>/{commands,events,aggregates,projections}/`).',
+                '',
+                '## 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`.',
+            ],
+        });
+        new projen_1.SampleFile(project, 'architecture-rules/rules.json', {
+            contents: JSON.stringify({ rules: [] }, null, 2) + '\n',
+        });
+    }
+}
+exports.SoftwareFactoryArchitectureRules = SoftwareFactoryArchitectureRules;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SoftwareFactoryArchitectureRules.js","sourceRoot":"","sources":["../src/SoftwareFactoryArchitectureRules.ts"],"names":[],"mappings":";;;AAAA,mCAAwD;AAGxD;;;;;GAKG;AACH,MAAa,gCAAgC;IAC3C,YAAY,OAAoB;QAC9B,IAAI,iBAAQ,CAAC,OAAO,EAAE,6BAA6B,EAAE;YACnD,MAAM,EAAE,IAAI;YACZ,KAAK,EAAE;gBACL,KAAK;gBACL,+EAA+E;gBAC/E,8EAA8E;gBAC9E,gFAAgF;gBAChF,8BAA8B;gBAC9B,KAAK;gBACL,gCAAgC;gBAChC,oCAAoC;gBACpC,uCAAuC;gBACvC,EAAE;gBACF,kCAAkC;gBAClC,6BAA6B;gBAC7B,oFAAoF;gBACpF,mBAAmB;gBACnB,mFAAmF;gBACnF,qBAAqB;gBACrB,GAAG;gBACH,EAAE;gBACF,kBAAkB;gBAClB,eAAe;gBACf,wBAAwB;gBACxB,qBAAqB;gBACrB,qDAAqD;gBACrD,gCAAgC;gBAChC,GAAG;gBACH,EAAE;gBACF,uBAAuB;gBACvB,mBAAmB;gBACnB,qBAAqB;gBACrB,oBAAoB;gBACpB,GAAG;gBACH,EAAE;gBACF,kDAAkD;gBAClD,sGAAsG;gBACtG,EAAE;gBACF,iFAAiF;gBACjF,+EAA+E;gBAC/E,iEAAiE;gBACjE,+CAA+C;gBAC/C,iBAAiB;gBACjB,2CAA2C;gBAC3C,wBAAwB;gBACxB,6CAA6C;gBAC7C,YAAY;gBACZ,kCAAkC;gBAClC,4BAA4B;gBAC5B,cAAc;gBACd,gBAAgB;gBAChB,sBAAsB;gBACtB,SAAS;gBACT,6BAA6B;gBAC7B,uBAAuB;gBACvB,6BAA6B;gBAC7B,sBAAsB;gBACtB,iDAAiD;gBACjD,0BAA0B;gBAC1B,cAAc;gBACd,iBAAiB;gBACjB,OAAO;gBACP,KAAK;gBACL,kCAAkC;gBAClC,GAAG;gBACH,EAAE;gBACF,kEAAkE;gBAClE,kEAAkE;gBAClE,GAAG;gBACH,EAAE;gBACF,oDAAoD;gBACpD,uEAAuE;gBACvE,GAAG;gBACH,EAAE;gBACF,4DAA4D;gBAC5D,uEAAuE;gBACvE,iDAAiD;gBACjD,8CAA8C;gBAC9C,gCAAgC;gBAChC,wBAAwB;gBACxB,iGAAiG;gBACjG,uBAAuB;gBACvB,OAAO;gBACP,KAAK;gBACL,eAAe;gBACf,GAAG;gBACH,EAAE;gBACF,qGAAqG;gBACrG,EAAE;gBACF,0DAA0D;gBAC1D,+BAA+B;gBAC/B,qCAAqC;gBACrC,sCAAsC;gBACtC,uDAAuD;gBACvD,2BAA2B;gBAC3B,KAAK;gBACL,iBAAiB;gBACjB,GAAG;gBACH,EAAE;gBACF,6EAA6E;gBAC7E,gFAAgF;gBAChF,cAAc;gBACd,yEAAyE;gBACzE,6FAA6F;gBAC7F,gEAAgE;gBAChE,GAAG;gBACH,EAAE;gBACF,6DAA6D;gBAC7D,wCAAwC;gBACxC,4DAA4D;gBAC5D,EAAE;gBACF,uCAAuC;gBACvC,yCAAyC;gBACzC,2CAA2C;gBAC3C,+CAA+C;gBAC/C,EAAE;gBACF,mDAAmD;gBACnD,uDAAuD;gBACvD,0DAA0D;gBAC1D,4EAA4E;gBAC5E,2BAA2B;gBAC3B,4BAA4B;gBAC5B,oCAAoC;gBACpC,gHAAgH;gBAChH,aAAa;gBACb,SAAS;gBACT,OAAO;gBACP,KAAK;gBACL,sBAAsB;gBACtB,GAAG;gBACH,EAAE;gBACF,kDAAkD;gBAClD,8BAA8B;gBAC9B,8BAA8B;gBAC9B,6CAA6C;gBAC7C,cAAc;gBACd,kIAAkI;gBAClI,KAAK;gBACL,GAAG;gBACH,EAAE;gBACF,2BAA2B;gBAC3B,yDAAyD;gBACzD,sBAAsB;gBACtB,qBAAqB;gBACrB,uCAAuC;gBACvC,EAAE;gBACF,+BAA+B;gBAC/B,0BAA0B;gBAC1B,mBAAmB;gBACnB,kEAAkE;gBAClE,iBAAiB;gBACjB,OAAO;gBACP,kBAAkB;gBAClB,6CAA6C;gBAC7C,KAAK;gBACL,EAAE;gBACF,kIAAkI;gBAClI,yCAAyC;gBACzC,2FAA2F;gBAC3F,KAAK;gBACL,EAAE;gBACF,yCAAyC;gBACzC,GAAG;gBACH,EAAE;gBACF,uBAAuB;aACxB;SACF,CAAC,CAAC;QAEH,IAAI,iBAAQ,CAAC,OAAO,EAAE,kCAAkC,EAAE;YACxD,MAAM,EAAE,KAAK;YACb,GAAG,EAAE;gBACH,OAAO,EAAE,kBAAkB;gBAC3B,eAAe,EAAE;oBACf,MAAM,EAAE,IAAI;oBACZ,OAAO,EAAE,GAAG;iBACb;gBACD,OAAO,EAAE,CAAC,MAAM,EAAE,QAAQ,CAAC;gBAC3B,OAAO,EAAE,CAAC,cAAc,CAAC;aAC1B;SACF,CAAC,CAAC;QAEH,IAAI,iBAAQ,CAAC,OAAO,EAAE,8BAA8B,EAAE;YACpD,MAAM,EAAE,IAAI;YACZ,KAAK,EAAE;gBACL,sBAAsB;gBACtB,EAAE;gBACF,kEAAkE;gBAClE,yEAAyE;gBACzE,6EAA6E;gBAC7E,2EAA2E;gBAC3E,2EAA2E;gBAC3E,sCAAsC;gBACtC,EAAE;gBACF,eAAe;gBACf,EAAE;gBACF,SAAS;gBACT,GAAG;gBACH,sBAAsB;gBACtB,iDAAiD;gBACjD,oBAAoB;gBACpB,uDAAuD;gBACvD,cAAc;gBACd,iCAAiC;gBACjC,mEAAmE;gBACnE,iEAAiE;gBACjE,KAAK;gBACL,GAAG;gBACH,KAAK;gBACL,EAAE;gBACF,yEAAyE;gBACzE,0EAA0E;gBAC1E,sCAAsC;gBACtC,EAAE;gBACF,kBAAkB;gBAClB,EAAE;gBACF,sEAAsE;gBACtE,sEAAsE;gBACtE,kEAAkE;gBAClE,EAAE;gBACF,wBAAwB;gBACxB,EAAE;gBACF,2EAA2E;gBAC3E,2EAA2E;gBAC3E,6EAA6E;gBAC7E,0EAA0E;gBAC1E,kDAAkD;aACnD;SACF,CAAC,CAAC;QAEH,IAAI,mBAAU,CAAC,OAAO,EAAE,+BAA+B,EAAE;YACvD,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI;SACxD,CAAC,CAAC;IACL,CAAC;CACF;AA3OD,4EA2OC","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"]}

package/lib/SoftwareFactoryAttestation.d.ts

@@ -0,0 +1,18 @@
+import { NodeProject } from 'projen/lib/javascript';
+export interface SoftwareFactoryAttestationOptions {
+    /**
+     * The bare repo name, used to point MANIFEST_FILES at
+     * `models/@swamp/software-factory/<repoName>-factory.yaml`.
+     */
+    readonly repoName: string;
+}
+/**
+ * The tamper-evident PR attestation mechanism: `manifest.ts` hashes the
+ * files that determine what pre-pr-verify checked, `verify.ts` re-checks
+ * those hashes (plus commit/status/freshness) against a PR's embedded
+ * `<!-- attestation-manifest -->` block at merge time. Fully generic engine
+ * logic — Batman owns and evolves these, so both are managed `TextFile`s.
+ */
+export declare class SoftwareFactoryAttestation {
+    constructor(project: NodeProject, options: SoftwareFactoryAttestationOptions);
+}