@macedon-technologies/batman 1.17.3 → 1.18.0

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);
+}

package/lib/SoftwareFactoryAttestation.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoftwareFactoryAttestation = void 0;
+const projen_1 = require("projen");
+/**
+ * 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.
+ */
+class SoftwareFactoryAttestation {
+    constructor(project, options) {
+        new projen_1.TextFile(project, 'attestation/manifest.ts', {
+            marker: true,
+            lines: [
+                '/**',
+                ' * Single source of truth for which files\' content determines "was this PR',
+                ' * actually verified against the rules it claims." Hashed by both the',
+                ' * pre-pr-verify workflow (to embed in the PR\'s attestation) and the',
+                ' * verify-attestation GitHub Action (to check nothing drifted since). Keeping',
+                ' * one list in one file is what keeps generator and checker from disagreeing',
+                ' * about what "the config" even is.',
+                ' */',
+                "import { createHash } from 'node:crypto';",
+                "import { readFileSync } from 'node:fs';",
+                "import { join } from 'node:path';",
+                '',
+                'export const MANIFEST_FILES: readonly string[] = [',
+                "  'workflows/workflow-pre-pr-verify.yaml',",
+                "  'workflows/workflow-openspec-plan-verify.yaml',",
+                "  'workflows/workflow-openspec-tasks-verify.yaml',",
+                `  'models/@swamp/software-factory/${options.repoName}-factory.yaml',`,
+                "  'architecture-rules/rules.json',",
+                "  'architecture-rules/check.ts',",
+                "  'openspec-gates/check-tasks-complete.ts',",
+                "  'CLAUDE.md',",
+                '];',
+                '',
+                'export interface Manifest {',
+                '  generatedAt: string;',
+                '  files: Record<string, string>;',
+                '}',
+                '',
+                "export function computeManifest(repoRoot: string = join(__dirname, '..')): Manifest {",
+                '  const files: Record<string, string> = {};',
+                '  for (const relativePath of MANIFEST_FILES) {',
+                '    const contents = readFileSync(join(repoRoot, relativePath));',
+                "    files[relativePath] = createHash('sha256').update(contents).digest('hex');",
+                '  }',
+                '  return { generatedAt: new Date().toISOString(), files };',
+                '}',
+                '',
+                'if (require.main === module) {',
+                '  console.log(JSON.stringify(computeManifest(), null, 2));',
+                '}',
+            ],
+        });
+        new projen_1.TextFile(project, 'attestation/verify.ts', {
+            marker: true,
+            lines: [
+                '/**',
+                ' * Checks the `<!-- attestation-manifest ... -->` block a factory-opened PR',
+                ' * embeds in its body (see the open-pr stage in',
+                ` * models/@swamp/software-factory/${options.repoName}-factory.yaml) against reality at the`,
+                ' * commit being merged. Per stack72.dev/ai-broke-the-assumptions-behind-ci/:',
+                ' * this proves the verification-relevant config hasn\'t drifted since the',
+                ' * attestation was generated — it does NOT independently prove the tests',
+                ' * in that attestation actually ran. That\'s an accepted limitation, not an',
+                ' * oversight; see the article and attestation/manifest.ts\'s own comment.',
+                ' */',
+                "import { readFileSync } from 'node:fs';",
+                "import { computeManifest, type Manifest } from './manifest';",
+                '',
+                'const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days',
+                '// Global, and deliberately loose about what\'s *between* the marker and the',
+                '// block\'s own closing "-->" — PR bodies can (and, it turns out, do) mention',
+                '// the literal "<!-- attestation-manifest -->" syntax in prose describing',
+                '// this mechanism. Each match is independently validated below; a mention',
+                '// with no JSON inside it is skipped rather than treated as a parse error.',
+                'const MANIFEST_BLOCK_RE = /<!--\\s*attestation-manifest([\\s\\S]*?)-->/g;',
+                '',
+                'interface EmbeddedManifest extends Manifest {',
+                '  commit: string;',
+                '  status: string;',
+                '}',
+                '',
+                'function isEmbeddedManifest(value: unknown): value is EmbeddedManifest {',
+                '  const candidate = value as Partial<EmbeddedManifest> | null;',
+                '  return (',
+                "    typeof candidate === 'object' &&",
+                '    candidate !== null &&',
+                "    typeof candidate.commit === 'string' &&",
+                "    typeof candidate.status === 'string' &&",
+                "    typeof candidate.generatedAt === 'string' &&",
+                "    typeof candidate.files === 'object' &&",
+                '    candidate.files !== null',
+                '  );',
+                '}',
+                '',
+                '// Balanced-brace scan rather than a regex for the JSON itself: the manifest',
+                '// has nested objects (files: {...}), so a non-greedy `\\{.*?\\}` would stop at',
+                '// the first inner "}" instead of the real end of the object.',
+                'function extractBalancedJson(text: string): string | null {',
+                "  const start = text.indexOf('{');",
+                '  if (start === -1) return null;',
+                '  let depth = 0;',
+                '  for (let i = start; i < text.length; i++) {',
+                "    if (text[i] === '{') depth++;",
+                "    else if (text[i] === '}') {",
+                '      depth--;',
+                '      if (depth === 0) return text.slice(start, i + 1);',
+                '    }',
+                '  }',
+                '  return null;',
+                '}',
+                '',
+                'function extractEmbeddedManifest(body: string): EmbeddedManifest {',
+                '  let matchedAnyBlock = false;',
+                '  for (const match of body.matchAll(MANIFEST_BLOCK_RE)) {',
+                '    matchedAnyBlock = true;',
+                '    const jsonText = extractBalancedJson(match[1]);',
+                '    if (!jsonText) continue;',
+                '    try {',
+                '      const parsed = JSON.parse(jsonText);',
+                '      if (isEmbeddedManifest(parsed)) return parsed;',
+                '    } catch {',
+                '      // Not this one — keep looking at the next attestation-manifest mention.',
+                '    }',
+                '  }',
+                '  throw new Error(',
+                '    matchedAnyBlock',
+                "      ? 'Found <!-- attestation-manifest --> mention(s) in the PR body, but none contained a complete, valid manifest.'",
+                "      : 'No <!-- attestation-manifest --> block found in the PR body. This PR was never verified by ' +",
+                '        \'pre-pr-verify (or the block was removed) — run the factory\\\'s pre-pr-verify workflow and re-open/update the PR.\',',
+                '  );',
+                '}',
+                '',
+                'function verify(prBody: string, expectedCommit: string): string[] {',
+                '  let embedded: EmbeddedManifest;',
+                '  try {',
+                '    embedded = extractEmbeddedManifest(prBody);',
+                '  } catch (err) {',
+                '    return [err instanceof Error ? err.message : String(err)];',
+                '  }',
+                '',
+                '  const errors: string[] = [];',
+                '',
+                '  if (embedded.commit !== expectedCommit) {',
+                '    errors.push(',
+                '      `Attestation is for commit ${embedded.commit}, but the PR\'s head commit is ${expectedCommit}. ` +',
+                "      'New commits were pushed without re-running pre-pr-verify.',",
+                '    );',
+                '  }',
+                '',
+                "  if (embedded.status !== 'succeeded') {",
+                '    errors.push(`Attestation status is "${embedded.status}", not "succeeded".`);',
+                '  }',
+                '',
+                '  const ageMs = Date.now() - Date.parse(embedded.generatedAt);',
+                '  if (!Number.isFinite(ageMs)) {',
+                '    errors.push(`Attestation generatedAt ("${embedded.generatedAt}") is not a parseable timestamp.`);',
+                '  } else if (ageMs > MAX_AGE_MS) {',
+                '    errors.push(`Attestation is ${Math.floor(ageMs / (24 * 60 * 60 * 1000))} days old (max ${MAX_AGE_MS / (24 * 60 * 60 * 1000)}) — re-run pre-pr-verify.`);',
+                '  }',
+                '',
+                '  const actual = computeManifest();',
+                '  for (const file of Object.keys(actual.files)) {',
+                '    if (embedded.files[file] !== actual.files[file]) {',
+                '      errors.push(`${file} has changed since the attestation was generated (expected ${embedded.files[file] ?? \'missing\'}, got ${actual.files[file]}).`);',
+                '    }',
+                '  }',
+                '  for (const file of Object.keys(embedded.files)) {',
+                '    if (!(file in actual.files)) {',
+                '      errors.push(`${file} is in the attestation manifest but no longer in the current file list (attestation/manifest.ts\'s MANIFEST_FILES changed).`);',
+                '    }',
+                '  }',
+                '',
+                '  return errors;',
+                '}',
+                '',
+                'function parseArgs(argv: string[]): { bodyFile: string; commit: string } {',
+                "  const bodyFile = argv[argv.indexOf('--body-file') + 1];",
+                "  const commit = argv[argv.indexOf('--commit') + 1];",
+                '  if (!bodyFile || !commit) {',
+                "    throw new Error('Usage: verify.ts --body-file <path> --commit <sha>');",
+                '  }',
+                '  return { bodyFile, commit };',
+                '}',
+                '',
+                'if (require.main === module) {',
+                '  const { bodyFile, commit } = parseArgs(process.argv.slice(2));',
+                "  const prBody = readFileSync(bodyFile, 'utf8');",
+                '  const errors = verify(prBody, commit);',
+                '  if (errors.length > 0) {',
+                "    console.error('Attestation verification failed:\\n');",
+                '    for (const error of errors) {',
+                '      console.error(`  - ${error}`);',
+                '    }',
+                '    process.exit(1);',
+                '  }',
+                '  console.log(`Attestation verified: commit ${commit}, all ${Object.keys(computeManifest().files).length} tracked files match.`);',
+                '}',
+            ],
+        });
+        new projen_1.JsonFile(project, 'attestation/tsconfig.json', {
+            marker: false,
+            obj: {
+                extends: '../tsconfig.json',
+                compilerOptions: {
+                    noEmit: true,
+                    rootDir: '.',
+                },
+                include: ['*.ts'],
+                exclude: ['node_modules'],
+            },
+        });
+    }
+}
+exports.SoftwareFactoryAttestation = SoftwareFactoryAttestation;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SoftwareFactoryAttestation.js","sourceRoot":"","sources":["../src/SoftwareFactoryAttestation.ts"],"names":[],"mappings":"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","sourcesContent":["import { JsonFile, TextFile } from 'projen';\nimport { NodeProject } from 'projen/lib/javascript';\n\nexport interface SoftwareFactoryAttestationOptions {\n  /**\n   * The bare repo name, used to point MANIFEST_FILES at\n   * `models/@swamp/software-factory/<repoName>-factory.yaml`.\n   */\n  readonly repoName: string;\n}\n\n/**\n * The tamper-evident PR attestation mechanism: `manifest.ts` hashes the\n * files that determine what pre-pr-verify checked, `verify.ts` re-checks\n * those hashes (plus commit/status/freshness) against a PR's embedded\n * `<!-- attestation-manifest -->` block at merge time. Fully generic engine\n * logic — Batman owns and evolves these, so both are managed `TextFile`s.\n */\nexport class SoftwareFactoryAttestation {\n  constructor(project: NodeProject, options: SoftwareFactoryAttestationOptions) {\n    new TextFile(project, 'attestation/manifest.ts', {\n      marker: true,\n      lines: [\n        '/**',\n        ' * Single source of truth for which files\\' content determines \"was this PR',\n        ' * actually verified against the rules it claims.\" Hashed by both the',\n        ' * pre-pr-verify workflow (to embed in the PR\\'s attestation) and the',\n        ' * verify-attestation GitHub Action (to check nothing drifted since). Keeping',\n        ' * one list in one file is what keeps generator and checker from disagreeing',\n        ' * about what \"the config\" even is.',\n        ' */',\n        \"import { createHash } from 'node:crypto';\",\n        \"import { readFileSync } from 'node:fs';\",\n        \"import { join } from 'node:path';\",\n        '',\n        'export const MANIFEST_FILES: readonly string[] = [',\n        \"  'workflows/workflow-pre-pr-verify.yaml',\",\n        \"  'workflows/workflow-openspec-plan-verify.yaml',\",\n        \"  'workflows/workflow-openspec-tasks-verify.yaml',\",\n        `  'models/@swamp/software-factory/${options.repoName}-factory.yaml',`,\n        \"  'architecture-rules/rules.json',\",\n        \"  'architecture-rules/check.ts',\",\n        \"  'openspec-gates/check-tasks-complete.ts',\",\n        \"  'CLAUDE.md',\",\n        '];',\n        '',\n        'export interface Manifest {',\n        '  generatedAt: string;',\n        '  files: Record<string, string>;',\n        '}',\n        '',\n        \"export function computeManifest(repoRoot: string = join(__dirname, '..')): Manifest {\",\n        '  const files: Record<string, string> = {};',\n        '  for (const relativePath of MANIFEST_FILES) {',\n        '    const contents = readFileSync(join(repoRoot, relativePath));',\n        \"    files[relativePath] = createHash('sha256').update(contents).digest('hex');\",\n        '  }',\n        '  return { generatedAt: new Date().toISOString(), files };',\n        '}',\n        '',\n        'if (require.main === module) {',\n        '  console.log(JSON.stringify(computeManifest(), null, 2));',\n        '}',\n      ],\n    });\n\n    new TextFile(project, 'attestation/verify.ts', {\n      marker: true,\n      lines: [\n        '/**',\n        ' * Checks the `<!-- attestation-manifest ... -->` block a factory-opened PR',\n        ' * embeds in its body (see the open-pr stage in',\n        ` * models/@swamp/software-factory/${options.repoName}-factory.yaml) against reality at the`,\n        ' * commit being merged. Per stack72.dev/ai-broke-the-assumptions-behind-ci/:',\n        ' * this proves the verification-relevant config hasn\\'t drifted since the',\n        ' * attestation was generated — it does NOT independently prove the tests',\n        ' * in that attestation actually ran. That\\'s an accepted limitation, not an',\n        ' * oversight; see the article and attestation/manifest.ts\\'s own comment.',\n        ' */',\n        \"import { readFileSync } from 'node:fs';\",\n        \"import { computeManifest, type Manifest } from './manifest';\",\n        '',\n        'const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days',\n        '// Global, and deliberately loose about what\\'s *between* the marker and the',\n        '// block\\'s own closing \"-->\" — PR bodies can (and, it turns out, do) mention',\n        '// the literal \"<!-- attestation-manifest -->\" syntax in prose describing',\n        '// this mechanism. Each match is independently validated below; a mention',\n        '// with no JSON inside it is skipped rather than treated as a parse error.',\n        'const MANIFEST_BLOCK_RE = /<!--\\\\s*attestation-manifest([\\\\s\\\\S]*?)-->/g;',\n        '',\n        'interface EmbeddedManifest extends Manifest {',\n        '  commit: string;',\n        '  status: string;',\n        '}',\n        '',\n        'function isEmbeddedManifest(value: unknown): value is EmbeddedManifest {',\n        '  const candidate = value as Partial<EmbeddedManifest> | null;',\n        '  return (',\n        \"    typeof candidate === 'object' &&\",\n        '    candidate !== null &&',\n        \"    typeof candidate.commit === 'string' &&\",\n        \"    typeof candidate.status === 'string' &&\",\n        \"    typeof candidate.generatedAt === 'string' &&\",\n        \"    typeof candidate.files === 'object' &&\",\n        '    candidate.files !== null',\n        '  );',\n        '}',\n        '',\n        '// Balanced-brace scan rather than a regex for the JSON itself: the manifest',\n        '// has nested objects (files: {...}), so a non-greedy `\\\\{.*?\\\\}` would stop at',\n        '// the first inner \"}\" instead of the real end of the object.',\n        'function extractBalancedJson(text: string): string | null {',\n        \"  const start = text.indexOf('{');\",\n        '  if (start === -1) return null;',\n        '  let depth = 0;',\n        '  for (let i = start; i < text.length; i++) {',\n        \"    if (text[i] === '{') depth++;\",\n        \"    else if (text[i] === '}') {\",\n        '      depth--;',\n        '      if (depth === 0) return text.slice(start, i + 1);',\n        '    }',\n        '  }',\n        '  return null;',\n        '}',\n        '',\n        'function extractEmbeddedManifest(body: string): EmbeddedManifest {',\n        '  let matchedAnyBlock = false;',\n        '  for (const match of body.matchAll(MANIFEST_BLOCK_RE)) {',\n        '    matchedAnyBlock = true;',\n        '    const jsonText = extractBalancedJson(match[1]);',\n        '    if (!jsonText) continue;',\n        '    try {',\n        '      const parsed = JSON.parse(jsonText);',\n        '      if (isEmbeddedManifest(parsed)) return parsed;',\n        '    } catch {',\n        '      // Not this one — keep looking at the next attestation-manifest mention.',\n        '    }',\n        '  }',\n        '  throw new Error(',\n        '    matchedAnyBlock',\n        \"      ? 'Found <!-- attestation-manifest --> mention(s) in the PR body, but none contained a complete, valid manifest.'\",\n        \"      : 'No <!-- attestation-manifest --> block found in the PR body. This PR was never verified by ' +\",\n        '        \\'pre-pr-verify (or the block was removed) — run the factory\\\\\\'s pre-pr-verify workflow and re-open/update the PR.\\',',\n        '  );',\n        '}',\n        '',\n        'function verify(prBody: string, expectedCommit: string): string[] {',\n        '  let embedded: EmbeddedManifest;',\n        '  try {',\n        '    embedded = extractEmbeddedManifest(prBody);',\n        '  } catch (err) {',\n        '    return [err instanceof Error ? err.message : String(err)];',\n        '  }',\n        '',\n        '  const errors: string[] = [];',\n        '',\n        '  if (embedded.commit !== expectedCommit) {',\n        '    errors.push(',\n        '      `Attestation is for commit ${embedded.commit}, but the PR\\'s head commit is ${expectedCommit}. ` +',\n        \"      'New commits were pushed without re-running pre-pr-verify.',\",\n        '    );',\n        '  }',\n        '',\n        \"  if (embedded.status !== 'succeeded') {\",\n        '    errors.push(`Attestation status is \"${embedded.status}\", not \"succeeded\".`);',\n        '  }',\n        '',\n        '  const ageMs = Date.now() - Date.parse(embedded.generatedAt);',\n        '  if (!Number.isFinite(ageMs)) {',\n        '    errors.push(`Attestation generatedAt (\"${embedded.generatedAt}\") is not a parseable timestamp.`);',\n        '  } else if (ageMs > MAX_AGE_MS) {',\n        '    errors.push(`Attestation is ${Math.floor(ageMs / (24 * 60 * 60 * 1000))} days old (max ${MAX_AGE_MS / (24 * 60 * 60 * 1000)}) — re-run pre-pr-verify.`);',\n        '  }',\n        '',\n        '  const actual = computeManifest();',\n        '  for (const file of Object.keys(actual.files)) {',\n        '    if (embedded.files[file] !== actual.files[file]) {',\n        '      errors.push(`${file} has changed since the attestation was generated (expected ${embedded.files[file] ?? \\'missing\\'}, got ${actual.files[file]}).`);',\n        '    }',\n        '  }',\n        '  for (const file of Object.keys(embedded.files)) {',\n        '    if (!(file in actual.files)) {',\n        '      errors.push(`${file} is in the attestation manifest but no longer in the current file list (attestation/manifest.ts\\'s MANIFEST_FILES changed).`);',\n        '    }',\n        '  }',\n        '',\n        '  return errors;',\n        '}',\n        '',\n        'function parseArgs(argv: string[]): { bodyFile: string; commit: string } {',\n        \"  const bodyFile = argv[argv.indexOf('--body-file') + 1];\",\n        \"  const commit = argv[argv.indexOf('--commit') + 1];\",\n        '  if (!bodyFile || !commit) {',\n        \"    throw new Error('Usage: verify.ts --body-file <path> --commit <sha>');\",\n        '  }',\n        '  return { bodyFile, commit };',\n        '}',\n        '',\n        'if (require.main === module) {',\n        '  const { bodyFile, commit } = parseArgs(process.argv.slice(2));',\n        \"  const prBody = readFileSync(bodyFile, 'utf8');\",\n        '  const errors = verify(prBody, commit);',\n        '  if (errors.length > 0) {',\n        \"    console.error('Attestation verification failed:\\\\n');\",\n        '    for (const error of errors) {',\n        '      console.error(`  - ${error}`);',\n        '    }',\n        '    process.exit(1);',\n        '  }',\n        '  console.log(`Attestation verified: commit ${commit}, all ${Object.keys(computeManifest().files).length} tracked files match.`);',\n        '}',\n      ],\n    });\n\n    new JsonFile(project, 'attestation/tsconfig.json', {\n      marker: false,\n      obj: {\n        extends: '../tsconfig.json',\n        compilerOptions: {\n          noEmit: true,\n          rootDir: '.',\n        },\n        include: ['*.ts'],\n        exclude: ['node_modules'],\n      },\n    });\n  }\n}\n"]}

package/lib/SoftwareFactoryFiles.d.ts

@@ -0,0 +1,45 @@
+import { NodeProject } from 'projen/lib/javascript';
+import { WorkflowActionVersions } from './WorkflowActionVersions';
+export interface SoftwareFactoryFilesOptions {
+    /**
+     * The bare repo name (e.g. `expense-tracker`), used to derive the factory's
+     * model names (`<repoName>-factory`, `<repoName>-issues`, `<repoName>-pr`,
+     * `<repoName>-shell*`) and vault name (`<repoName>-secrets`).
+     */
+    readonly repoName: string;
+    /**
+     * The branch the factory opens pull requests against.
+     *
+     * @default 'main'
+     */
+    readonly baseBranch?: string;
+    /**
+     * Overrides for the pinned action versions used by `verify-attestation.yml`.
+     */
+    readonly actionVersions?: WorkflowActionVersions;
+}
+/**
+ * Backports exman's swamp "software factory" pattern
+ * (macedon-technologies/exman#13) as generated scaffolding: a
+ * `@swamp/software-factory` state machine that drives a GitHub issue from
+ * intake through an opened PR, enforcing OpenSpec usage, an architecture
+ * rule registry, and a pre-PR verification gate whose attestation is
+ * re-checked at merge time.
+ *
+ * What swamp itself would generate (extension docs pulled via
+ * `swamp extension pull`, `.swamp.yaml`, the vault, and the "swamp managed
+ * section" in CLAUDE.md) is deliberately NOT hand-templated here — those are
+ * produced by the real `swamp` CLI. `swamp init` is idempotent (a no-op if
+ * the repo is already initialized), so it's wired into the project's
+ * `install`/`install:ci` tasks and runs automatically on every install,
+ * guarded so it's a silent no-op on a machine without `swamp` on PATH (e.g.
+ * CI). The extension pulls and vault creation are one-time, not idempotent
+ * in a way that's safe to repeat on every install, so they stay in the
+ * `swamp:bootstrap` task this construct adds. Only exman's own authored
+ * config (the factory's state machine, the architecture-rule engine, the
+ * attestation mechanism, the OpenSpec task-completion gate, and the 3 swamp
+ * workflows that wire them together) is templated.
+ */
+export declare class SoftwareFactoryFiles {
+    constructor(project: NodeProject, options: SoftwareFactoryFilesOptions);
+}