@macedon-technologies/batman 1.24.2 → 1.25.1

package/lib/SoftwareFactoryArchitectureRules.js

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

package/lib/SoftwareFactoryFiles.js

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

package/lib/SoftwareFactoryWorkflows.js

@@ -24,6 +24,25 @@ class SoftwareFactoryWorkflows {
         const shellModel = `${repoName}-shell`;
         const shellArchitectureModel = `${repoName}-shell-architecture`;
         const shellManifestModel = `${repoName}-shell-manifest`;
+        // Each job step's `run:` below executes through swamp's command/shell model, which runs
+        // the string through the host's native shell — bash/sh on macOS/Linux, but Windows
+        // PowerShell 5.1 on a Windows dev machine. PowerShell 5.1 has no `&&`/`||` chain operators
+        // and aliases `rm` to `Remove-Item` (whose `-f` is ambiguous with `-Filter`). If a step
+        // here needs more than one command, prefer a single package.json script that does the
+        // sequencing, or use `;` to separate commands (accepted by both shells, though it does not
+        // short-circuit on failure — rely on the workflow's own assert step for that). To
+        // force-delete a file portably, use `node -e "require('fs').rmSync('<path>', {force:
+        // true})"` instead of `rm -f <path>` (see shellPortableSequence/shellPortableForceDelete
+        // in utils.ts).
+        const shellPortabilityNote = `# Portability note: \`run:\` below executes through swamp's command/shell model, which runs
+# the string through the host's native shell — bash/sh on macOS/Linux, but Windows
+# PowerShell 5.1 on a Windows dev machine. PowerShell 5.1 has no \`&&\`/\`||\` chain operators
+# and aliases \`rm\` to \`Remove-Item\` (whose \`-f\` is ambiguous with \`-Filter\`). If a step here
+# needs more than one command, prefer a single package.json script that does the
+# sequencing, or use \`;\` to separate commands (accepted by both shells, though it does not
+# short-circuit on failure — rely on the workflow's own assert step for that). To
+# force-delete a file portably, use \`node -e "require('fs').rmSync('<path>', {force: true})"\`
+# instead of \`rm -f <path>\`.`;
         new projen_1.SampleFile(project, 'workflows/workflow-openspec-plan-verify.yaml', {
             contents: `id: ${(0, crypto_1.randomUUID)()}
 name: openspec-plan-verify
@@ -40,6 +59,7 @@ inputs:
     changeSlug:
       type: string
       description: The openspec change name (openspec/changes/<changeSlug>/).
+${shellPortabilityNote}
 jobs:
   - name: verify
     description: Validate the OpenSpec change is complete and well-formed
@@ -95,6 +115,7 @@ inputs:
     changeSlug:
       type: string
       description: The openspec change name (openspec/changes/<changeSlug>/).
+${shellPortabilityNote}
 jobs:
   - name: verify
     description: Check every task in the change's tasks.md is complete
@@ -152,6 +173,7 @@ inputs:
     branch:
       type: string
       description: Same as commit, but for @swamp/verification-attestation's subject.branch.
+${shellPortabilityNote}
 jobs:
   - name: verify
     description: Build/test/lint plus architecture-rule checks, gating PR creation
@@ -324,4 +346,4 @@ version: 1
     }
 }
 exports.SoftwareFactoryWorkflows = SoftwareFactoryWorkflows;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SoftwareFactoryWorkflows.js","sourceRoot":"","sources":["../src/SoftwareFactoryWorkflows.ts"],"names":[],"mappings":";;;AAAA,mCAAoC;AACpC,mCAA8C;AAC9C,sDAAwE;AACxE,mCAA2D;AAC3D,qEAAyF;AAezF;;;;;;;;;;;GAWG;AACH,MAAa,wBAAwB;IACnC,YAAY,OAAoB,EAAE,OAAwC;QACxE,MAAM,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC;QAC7B,MAAM,UAAU,GAAG,GAAG,QAAQ,QAAQ,CAAC;QACvC,MAAM,sBAAsB,GAAG,GAAG,QAAQ,qBAAqB,CAAC;QAChE,MAAM,kBAAkB,GAAG,GAAG,QAAQ,iBAAiB,CAAC;QAExD,IAAI,mBAAU,CAAC,OAAO,EAAE,8CAA8C,EAAE;YACtE,QAAQ,EAAE,OAAO,IAAA,mBAAU,GAAE;;;;;;;;;;;;;;;;;;;;;;;2BAuBR,UAAU;;;;;;;;;;;;wCAYG,UAAU;;;;qDAIG,UAAU;;;;;;;;;;;;CAY9D;SACI,CAAC,CAAC;QAEH,IAAI,mBAAU,CAAC,OAAO,EAAE,+CAA+C,EAAE;YACvE,QAAQ,EAAE,OAAO,IAAA,mBAAU,GAAE;;;;;;;;;;;;;;;;;;;;;;;;2BAwBR,UAAU;;;;;;;;;;;;wCAYG,UAAU;;;6DAGW,UAAU;;;;;;;;;;;;CAYtE;SACI,CAAC,CAAC;QAEH,IAAI,mBAAU,CAAC,OAAO,EAAE,uCAAuC,EAAE;YAC/D,QAAQ,EAAE,OAAO,IAAA,mBAAU,GAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA2BR,UAAU;;;;;;;;;;;;wCAYG,UAAU;;;oEAGkB,UAAU;;;;;;;;;;;;;2BAanD,sBAAsB;;;;;;;;;;;;;;;wCAeT,sBAAsB;;;6DAGD,UAAU;;;;;;;;;;;;;;;2BAe5C,kBAAkB;;;;;;;;;;;;;;;wCAeL,kBAAkB;;;;cAI5C,kBAAkB;;;;;;;;;;;CAW/B;SACI,CAAC,CAAC;QAEH,MAAM,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC;QACtD,MAAM,cAAc,GAAG,IAAA,8CAAqB,EAAC,OAAO,CAAC,cAAc,CAAC,CAAC;QAErE,IAAI,iBAAQ,CAAC,OAAO,EAAE,0CAA0C,EAAE;YAChE,MAAM,EAAE,IAAI;YACZ,QAAQ,EAAE,IAAI;YACd,GAAG,EAAE;gBACH,IAAI,EAAE,oBAAoB;gBAC1B,EAAE,EAAE;oBACF,YAAY,EAAE;wBACZ,KAAK,EAAE,CAAC,QAAQ,EAAE,aAAa,EAAE,UAAU,CAAC;qBAC7C;iBACF;gBACD,WAAW,EAAE;oBACX,UAAU,EAAE,MAAM;oBAClB,eAAe,EAAE,MAAM;iBACxB;gBACD,IAAI,EAAE;oBACJ,MAAM,EAAE;wBACN,SAAS,EAAE,eAAe;wBAC1B,OAAO,EAAE;4BACP;gCACE,IAAI,EAAE,UAAU;gCAChB,IAAI,EAAE,cAAc,CAAC,QAAQ;gCAC7B,IAAI,EAAE;oCACJ,KAAK,EAAE,2CAA2C;oCAClD,qBAAqB,EAAE,KAAK;iCAC7B;6BACF;4BACD,GAAG,CAAC,cAAc,KAAK,+BAAkB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;oCAChD,IAAI,EAAE,YAAY;oCAClB,IAAI,EAAE,cAAc,CAAC,eAAe;iCACrC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;4BACR;gCACE,IAAI,EAAE,eAAe;gCACrB,IAAI,EAAE,cAAc,CAAC,SAAS;gCAC9B,IAAI,EAAE;oCACJ,cAAc,EAAE,IAAI;oCACpB,uBAAuB,EAAE,KAAK;iCAC/B;6BACF;4BACD;gCACE,IAAI,EAAE,sBAAsB;gCAC5B,GAAG,EAAE,IAAA,sBAAc,EAAC,cAAc,CAAC;6BACpC;4BACD;gCACE,IAAI,EAAE,eAAe;gCACrB,GAAG,EAAE;oCACH,QAAQ,EAAE,6BAA6B;iCACxC;gCACD,GAAG,EAAE;oCACH,uDAAuD;oCACvD,sCAAsC;oCACtC,0CAA0C;iCAC3C,CAAC,IAAI,CAAC,IAAI,CAAC;6BACb;4BACD;gCACE,IAAI,EAAE,oBAAoB;gCAC1B,GAAG,EAAE;oCACH,GAAG,IAAA,wBAAgB,EAAC,cAAc,EAAE,oBAAoB,CAAC,QAAQ;oCACjE,kCAAkC;oCAClC,sDAAsD;iCACvD,CAAC,IAAI,CAAC,IAAI,CAAC;6BACb;yBACF;qBACF;iBACF;aACF;SACF,CAAC,CAAC;IACL,CAAC;CACF;AArTD,4DAqTC","sourcesContent":["import { randomUUID } from 'crypto';\nimport { SampleFile, YamlFile } from 'projen';\nimport { NodePackageManager, NodeProject } from 'projen/lib/javascript';\nimport { installCommand, runScriptCommand } from './utils';\nimport { resolveActionVersions, WorkflowActionVersions } from './WorkflowActionVersions';\n\nexport interface SoftwareFactoryWorkflowsOptions {\n  /**\n   * The bare repo name, used to derive the `<repoName>-shell[-architecture|-manifest]`\n   * model names these workflows dispatch shell commands through.\n   */\n  readonly repoName: string;\n\n  /**\n   * Overrides for the pinned action versions used by `verify-attestation.yml`.\n   */\n  readonly actionVersions?: WorkflowActionVersions;\n}\n\n/**\n * The 3 swamp workflows the factory's gate stages run (openspec-plan-verify,\n * openspec-tasks-verify, pre-pr-verify), plus the GitHub Action that\n * re-verifies a PR's embedded attestation at merge time.\n *\n * The swamp workflow YAMLs carry a swamp-assigned `id` that must stay stable\n * across synths (swamp uses it as the workflow's identity), so — like the\n * model instances in `SoftwareFactoryModels` — they're `SampleFile`s, written\n * once and then owned by the team. `verify-attestation.yml` has no such\n * identity constraint and is a plain GitHub Actions workflow, so it's built\n * the same managed way `PrDeployWorkflow` is.\n */\nexport class SoftwareFactoryWorkflows {\n  constructor(project: NodeProject, options: SoftwareFactoryWorkflowsOptions) {\n    const { repoName } = options;\n    const shellModel = `${repoName}-shell`;\n    const shellArchitectureModel = `${repoName}-shell-architecture`;\n    const shellManifestModel = `${repoName}-shell-manifest`;\n\n    new SampleFile(project, 'workflows/workflow-openspec-plan-verify.yaml', {\n      contents: `id: ${randomUUID()}\nname: openspec-plan-verify\ndescription: >-\n  Fails unless the named OpenSpec change is well-formed (proposal, design,\n  specs with deltas, tasks all present) via \\`openspec validate\\`. Gates the\n  factory's planning stage: a request can't proceed to implementation until\n  it's a real OpenSpec change, not just prose in a swamp artifact.\ntags: {}\ninputs:\n  type: object\n  required: [changeSlug]\n  properties:\n    changeSlug:\n      type: string\n      description: The openspec change name (openspec/changes/<changeSlug>/).\njobs:\n  - name: verify\n    description: Validate the OpenSpec change is complete and well-formed\n    steps:\n      - name: validate\n        description: openspec validate <changeSlug> --type change\n        task:\n          type: model_method\n          modelIdOrName: ${shellModel}\n          methodName: execute\n          inputs:\n            run: 'openspec validate \\${{ inputs.changeSlug }} --type change'\n        dependsOn: []\n        weight: 0\n        allowFailure: false\n      - name: assert-valid\n        description: openspec validate must exit 0\n        task:\n          type: assert\n          expr: >-\n            data.query('modelName == \"${shellModel}\" && name == \"result\" &&\n            workflowRunId == \"' + run.id + '\"')[0].attributes.exitCode == 0\n          message: >-\n            OpenSpec change is not valid/complete (missing proposal, design,\n            specs with deltas, or tasks) — see the ${shellModel} result data\n            for openspec's own remediation output\n          severity: high\n        dependsOn:\n          - step: validate\n            condition:\n              type: succeeded\n        weight: 0\n        allowFailure: false\n    dependsOn: []\n    weight: 0\nversion: 1\n`,\n    });\n\n    new SampleFile(project, 'workflows/workflow-openspec-tasks-verify.yaml', {\n      contents: `id: ${randomUUID()}\nname: openspec-tasks-verify\ndescription: >-\n  Fails unless every task in the named OpenSpec change's tasks.md is checked\n  off (openspec-gates/check-tasks-complete.ts, via \\`pnpm run\n  openspec:check-tasks-complete\\`). Gates the factory's implementing stage:\n  work isn't done until the change's own task list says it's done, not just\n  because an artifact was recorded.\ntags: {}\ninputs:\n  type: object\n  required: [changeSlug]\n  properties:\n    changeSlug:\n      type: string\n      description: The openspec change name (openspec/changes/<changeSlug>/).\njobs:\n  - name: verify\n    description: Check every task in the change's tasks.md is complete\n    steps:\n      - name: check-tasks\n        description: pnpm run openspec:check-tasks-complete -- <changeSlug>\n        task:\n          type: model_method\n          modelIdOrName: ${shellModel}\n          methodName: execute\n          inputs:\n            run: 'pnpm run openspec:check-tasks-complete -- \\${{ inputs.changeSlug }}'\n        dependsOn: []\n        weight: 0\n        allowFailure: false\n      - name: assert-tasks-complete\n        description: openspec:check-tasks-complete must exit 0\n        task:\n          type: assert\n          expr: >-\n            data.query('modelName == \"${shellModel}\" && name == \"result\" &&\n            workflowRunId == \"' + run.id + '\"')[0].attributes.exitCode == 0\n          message: >-\n            OpenSpec change has incomplete tasks — see the ${shellModel}\n            result data for the completedTasks/totalTasks breakdown\n          severity: high\n        dependsOn:\n          - step: check-tasks\n            condition:\n              type: succeeded\n        weight: 0\n        allowFailure: false\n    dependsOn: []\n    weight: 0\nversion: 1\n`,\n    });\n\n    new SampleFile(project, 'workflows/workflow-pre-pr-verify.yaml', {\n      contents: `id: ${randomUUID()}\nname: pre-pr-verify\ndescription: >-\n  Pre-PR verification: run the same checks CI would run, before the factory\n  opens a PR rather than after — build/synth/test/lint (pnpm build) and the\n  architecture rule registry (pnpm validate:architecture). Both must pass.\ntags: {}\ninputs:\n  type: object\n  properties:\n    commit:\n      type: string\n      description: >-\n        The commit sha being verified. Read by the built-in\n        @swamp/verification-attestation report's subject.commit — pass the\n        real HEAD sha or the attestation renders \"unknown\".\n    branch:\n      type: string\n      description: Same as commit, but for @swamp/verification-attestation's subject.branch.\njobs:\n  - name: verify\n    description: Build/test/lint plus architecture-rule checks, gating PR creation\n    steps:\n      - name: build\n        description: compile -> cdk synth -> jest -> eslint (existing projen build task)\n        task:\n          type: model_method\n          modelIdOrName: ${shellModel}\n          methodName: execute\n          inputs:\n            run: pnpm build\n        dependsOn: []\n        weight: 0\n        allowFailure: false\n      - name: assert-build\n        description: pnpm build must exit 0\n        task:\n          type: assert\n          expr: >-\n            data.query('modelName == \"${shellModel}\" && name == \"result\" &&\n            workflowRunId == \"' + run.id + '\"')[0].attributes.exitCode == 0\n          message: >-\n            pnpm build failed (compile/synth/test/lint) — see the ${shellModel}\n            result data for stdout/stderr\n          severity: high\n        dependsOn:\n          - step: build\n            condition:\n              type: succeeded\n        weight: 0\n        allowFailure: false\n      - name: architecture\n        description: run the architecture rule registry (architecture-rules/rules.json)\n        task:\n          type: model_method\n          modelIdOrName: ${shellArchitectureModel}\n          methodName: execute\n          inputs:\n            run: pnpm run validate:architecture\n        dependsOn:\n          - step: assert-build\n            condition:\n              type: succeeded\n        weight: 0\n        allowFailure: false\n      - name: assert-architecture\n        description: architecture rule registry must exit 0 (no enabled-rule violations)\n        task:\n          type: assert\n          expr: >-\n            data.query('modelName == \"${shellArchitectureModel}\" && name == \"result\" &&\n            workflowRunId == \"' + run.id + '\"')[0].attributes.exitCode == 0\n          message: >-\n            architecture rule violation(s) found — see the ${shellModel} result\n            data for details\n          severity: high\n        dependsOn:\n          - step: architecture\n            condition:\n              type: succeeded\n        weight: 0\n        allowFailure: false\n      - name: manifest\n        description: >-\n          compute the attestation-manifest checksums (attestation/manifest.ts)\n          that verify-attestation.yml re-checks at merge time\n        task:\n          type: model_method\n          modelIdOrName: ${shellManifestModel}\n          methodName: execute\n          inputs:\n            run: pnpm run attestation:manifest\n        dependsOn:\n          - step: assert-architecture\n            condition:\n              type: succeeded\n        weight: 0\n        allowFailure: false\n      - name: assert-manifest\n        description: attestation:manifest must exit 0\n        task:\n          type: assert\n          expr: >-\n            data.query('modelName == \"${shellManifestModel}\" && name == \"result\" &&\n            workflowRunId == \"' + run.id + '\"')[0].attributes.exitCode == 0\n          message: >-\n            failed to compute the attestation manifest — see the\n            ${shellManifestModel} result data for stdout/stderr\n          severity: high\n        dependsOn:\n          - step: manifest\n            condition:\n              type: succeeded\n        weight: 0\n        allowFailure: false\n    dependsOn: []\n    weight: 0\nversion: 1\n`,\n    });\n\n    const packageManager = project.package.packageManager;\n    const actionVersions = resolveActionVersions(options.actionVersions);\n\n    new YamlFile(project, '.github/workflows/verify-attestation.yml', {\n      marker: true,\n      readonly: true,\n      obj: {\n        name: 'Verify Attestation',\n        on: {\n          pull_request: {\n            types: ['opened', 'synchronize', 'reopened'],\n          },\n        },\n        permissions: {\n          'contents': 'read',\n          'pull-requests': 'read',\n        },\n        jobs: {\n          verify: {\n            'runs-on': 'ubuntu-latest',\n            'steps': [\n              {\n                name: 'Checkout',\n                uses: actionVersions.checkout,\n                with: {\n                  'ref': '${{ github.event.pull_request.head.sha }}',\n                  'persist-credentials': false,\n                },\n              },\n              ...(packageManager === NodePackageManager.PNPM ? [{\n                name: 'Setup pnpm',\n                uses: actionVersions.pnpmActionSetup,\n              }] : []),\n              {\n                name: 'Setup Node.js',\n                uses: actionVersions.setupNode,\n                with: {\n                  'node-version': '24',\n                  'package-manager-cache': false,\n                },\n              },\n              {\n                name: 'Install dependencies',\n                run: installCommand(packageManager),\n              },\n              {\n                name: 'Fetch PR body',\n                env: {\n                  GH_TOKEN: '${{ secrets.GITHUB_TOKEN }}',\n                },\n                run: [\n                  'gh pr view ${{ github.event.pull_request.number }} \\\\',\n                  '  --repo ${{ github.repository }} \\\\',\n                  '  --json body -q .body > /tmp/pr-body.md',\n                ].join('\\n'),\n              },\n              {\n                name: 'Verify attestation',\n                run: [\n                  `${runScriptCommand(packageManager, 'attestation:verify')} -- \\\\`,\n                  '  --body-file /tmp/pr-body.md \\\\',\n                  '  --commit ${{ github.event.pull_request.head.sha }}',\n                ].join('\\n'),\n              },\n            ],\n          },\n        },\n      },\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SoftwareFactoryWorkflows.js","sourceRoot":"","sources":["../src/SoftwareFactoryWorkflows.ts"],"names":[],"mappings":"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","sourcesContent":["import { randomUUID } from 'crypto';\nimport { SampleFile, YamlFile } from 'projen';\nimport { NodePackageManager, NodeProject } from 'projen/lib/javascript';\nimport { installCommand, runScriptCommand } from './utils';\nimport { resolveActionVersions, WorkflowActionVersions } from './WorkflowActionVersions';\n\nexport interface SoftwareFactoryWorkflowsOptions {\n  /**\n   * The bare repo name, used to derive the `<repoName>-shell[-architecture|-manifest]`\n   * model names these workflows dispatch shell commands through.\n   */\n  readonly repoName: string;\n\n  /**\n   * Overrides for the pinned action versions used by `verify-attestation.yml`.\n   */\n  readonly actionVersions?: WorkflowActionVersions;\n}\n\n/**\n * The 3 swamp workflows the factory's gate stages run (openspec-plan-verify,\n * openspec-tasks-verify, pre-pr-verify), plus the GitHub Action that\n * re-verifies a PR's embedded attestation at merge time.\n *\n * The swamp workflow YAMLs carry a swamp-assigned `id` that must stay stable\n * across synths (swamp uses it as the workflow's identity), so — like the\n * model instances in `SoftwareFactoryModels` — they're `SampleFile`s, written\n * once and then owned by the team. `verify-attestation.yml` has no such\n * identity constraint and is a plain GitHub Actions workflow, so it's built\n * the same managed way `PrDeployWorkflow` is.\n */\nexport class SoftwareFactoryWorkflows {\n  constructor(project: NodeProject, options: SoftwareFactoryWorkflowsOptions) {\n    const { repoName } = options;\n    const shellModel = `${repoName}-shell`;\n    const shellArchitectureModel = `${repoName}-shell-architecture`;\n    const shellManifestModel = `${repoName}-shell-manifest`;\n\n    // Each job step's `run:` below executes through swamp's command/shell model, which runs\n    // the string through the host's native shell — bash/sh on macOS/Linux, but Windows\n    // PowerShell 5.1 on a Windows dev machine. PowerShell 5.1 has no `&&`/`||` chain operators\n    // and aliases `rm` to `Remove-Item` (whose `-f` is ambiguous with `-Filter`). If a step\n    // here needs more than one command, prefer a single package.json script that does the\n    // sequencing, or use `;` to separate commands (accepted by both shells, though it does not\n    // short-circuit on failure — rely on the workflow's own assert step for that). To\n    // force-delete a file portably, use `node -e \"require('fs').rmSync('<path>', {force:\n    // true})\"` instead of `rm -f <path>` (see shellPortableSequence/shellPortableForceDelete\n    // in utils.ts).\n    const shellPortabilityNote = `# Portability note: \\`run:\\` below executes through swamp's command/shell model, which runs\n# the string through the host's native shell — bash/sh on macOS/Linux, but Windows\n# PowerShell 5.1 on a Windows dev machine. PowerShell 5.1 has no \\`&&\\`/\\`||\\` chain operators\n# and aliases \\`rm\\` to \\`Remove-Item\\` (whose \\`-f\\` is ambiguous with \\`-Filter\\`). If a step here\n# needs more than one command, prefer a single package.json script that does the\n# sequencing, or use \\`;\\` to separate commands (accepted by both shells, though it does not\n# short-circuit on failure — rely on the workflow's own assert step for that). To\n# force-delete a file portably, use \\`node -e \"require('fs').rmSync('<path>', {force: true})\"\\`\n# instead of \\`rm -f <path>\\`.`;\n\n    new SampleFile(project, 'workflows/workflow-openspec-plan-verify.yaml', {\n      contents: `id: ${randomUUID()}\nname: openspec-plan-verify\ndescription: >-\n  Fails unless the named OpenSpec change is well-formed (proposal, design,\n  specs with deltas, tasks all present) via \\`openspec validate\\`. Gates the\n  factory's planning stage: a request can't proceed to implementation until\n  it's a real OpenSpec change, not just prose in a swamp artifact.\ntags: {}\ninputs:\n  type: object\n  required: [changeSlug]\n  properties:\n    changeSlug:\n      type: string\n      description: The openspec change name (openspec/changes/<changeSlug>/).\n${shellPortabilityNote}\njobs:\n  - name: verify\n    description: Validate the OpenSpec change is complete and well-formed\n    steps:\n      - name: validate\n        description: openspec validate <changeSlug> --type change\n        task:\n          type: model_method\n          modelIdOrName: ${shellModel}\n          methodName: execute\n          inputs:\n            run: 'openspec validate \\${{ inputs.changeSlug }} --type change'\n        dependsOn: []\n        weight: 0\n        allowFailure: false\n      - name: assert-valid\n        description: openspec validate must exit 0\n        task:\n          type: assert\n          expr: >-\n            data.query('modelName == \"${shellModel}\" && name == \"result\" &&\n            workflowRunId == \"' + run.id + '\"')[0].attributes.exitCode == 0\n          message: >-\n            OpenSpec change is not valid/complete (missing proposal, design,\n            specs with deltas, or tasks) — see the ${shellModel} result data\n            for openspec's own remediation output\n          severity: high\n        dependsOn:\n          - step: validate\n            condition:\n              type: succeeded\n        weight: 0\n        allowFailure: false\n    dependsOn: []\n    weight: 0\nversion: 1\n`,\n    });\n\n    new SampleFile(project, 'workflows/workflow-openspec-tasks-verify.yaml', {\n      contents: `id: ${randomUUID()}\nname: openspec-tasks-verify\ndescription: >-\n  Fails unless every task in the named OpenSpec change's tasks.md is checked\n  off (openspec-gates/check-tasks-complete.ts, via \\`pnpm run\n  openspec:check-tasks-complete\\`). Gates the factory's implementing stage:\n  work isn't done until the change's own task list says it's done, not just\n  because an artifact was recorded.\ntags: {}\ninputs:\n  type: object\n  required: [changeSlug]\n  properties:\n    changeSlug:\n      type: string\n      description: The openspec change name (openspec/changes/<changeSlug>/).\n${shellPortabilityNote}\njobs:\n  - name: verify\n    description: Check every task in the change's tasks.md is complete\n    steps:\n      - name: check-tasks\n        description: pnpm run openspec:check-tasks-complete -- <changeSlug>\n        task:\n          type: model_method\n          modelIdOrName: ${shellModel}\n          methodName: execute\n          inputs:\n            run: 'pnpm run openspec:check-tasks-complete -- \\${{ inputs.changeSlug }}'\n        dependsOn: []\n        weight: 0\n        allowFailure: false\n      - name: assert-tasks-complete\n        description: openspec:check-tasks-complete must exit 0\n        task:\n          type: assert\n          expr: >-\n            data.query('modelName == \"${shellModel}\" && name == \"result\" &&\n            workflowRunId == \"' + run.id + '\"')[0].attributes.exitCode == 0\n          message: >-\n            OpenSpec change has incomplete tasks — see the ${shellModel}\n            result data for the completedTasks/totalTasks breakdown\n          severity: high\n        dependsOn:\n          - step: check-tasks\n            condition:\n              type: succeeded\n        weight: 0\n        allowFailure: false\n    dependsOn: []\n    weight: 0\nversion: 1\n`,\n    });\n\n    new SampleFile(project, 'workflows/workflow-pre-pr-verify.yaml', {\n      contents: `id: ${randomUUID()}\nname: pre-pr-verify\ndescription: >-\n  Pre-PR verification: run the same checks CI would run, before the factory\n  opens a PR rather than after — build/synth/test/lint (pnpm build) and the\n  architecture rule registry (pnpm validate:architecture). Both must pass.\ntags: {}\ninputs:\n  type: object\n  properties:\n    commit:\n      type: string\n      description: >-\n        The commit sha being verified. Read by the built-in\n        @swamp/verification-attestation report's subject.commit — pass the\n        real HEAD sha or the attestation renders \"unknown\".\n    branch:\n      type: string\n      description: Same as commit, but for @swamp/verification-attestation's subject.branch.\n${shellPortabilityNote}\njobs:\n  - name: verify\n    description: Build/test/lint plus architecture-rule checks, gating PR creation\n    steps:\n      - name: build\n        description: compile -> cdk synth -> jest -> eslint (existing projen build task)\n        task:\n          type: model_method\n          modelIdOrName: ${shellModel}\n          methodName: execute\n          inputs:\n            run: pnpm build\n        dependsOn: []\n        weight: 0\n        allowFailure: false\n      - name: assert-build\n        description: pnpm build must exit 0\n        task:\n          type: assert\n          expr: >-\n            data.query('modelName == \"${shellModel}\" && name == \"result\" &&\n            workflowRunId == \"' + run.id + '\"')[0].attributes.exitCode == 0\n          message: >-\n            pnpm build failed (compile/synth/test/lint) — see the ${shellModel}\n            result data for stdout/stderr\n          severity: high\n        dependsOn:\n          - step: build\n            condition:\n              type: succeeded\n        weight: 0\n        allowFailure: false\n      - name: architecture\n        description: run the architecture rule registry (architecture-rules/rules.json)\n        task:\n          type: model_method\n          modelIdOrName: ${shellArchitectureModel}\n          methodName: execute\n          inputs:\n            run: pnpm run validate:architecture\n        dependsOn:\n          - step: assert-build\n            condition:\n              type: succeeded\n        weight: 0\n        allowFailure: false\n      - name: assert-architecture\n        description: architecture rule registry must exit 0 (no enabled-rule violations)\n        task:\n          type: assert\n          expr: >-\n            data.query('modelName == \"${shellArchitectureModel}\" && name == \"result\" &&\n            workflowRunId == \"' + run.id + '\"')[0].attributes.exitCode == 0\n          message: >-\n            architecture rule violation(s) found — see the ${shellModel} result\n            data for details\n          severity: high\n        dependsOn:\n          - step: architecture\n            condition:\n              type: succeeded\n        weight: 0\n        allowFailure: false\n      - name: manifest\n        description: >-\n          compute the attestation-manifest checksums (attestation/manifest.ts)\n          that verify-attestation.yml re-checks at merge time\n        task:\n          type: model_method\n          modelIdOrName: ${shellManifestModel}\n          methodName: execute\n          inputs:\n            run: pnpm run attestation:manifest\n        dependsOn:\n          - step: assert-architecture\n            condition:\n              type: succeeded\n        weight: 0\n        allowFailure: false\n      - name: assert-manifest\n        description: attestation:manifest must exit 0\n        task:\n          type: assert\n          expr: >-\n            data.query('modelName == \"${shellManifestModel}\" && name == \"result\" &&\n            workflowRunId == \"' + run.id + '\"')[0].attributes.exitCode == 0\n          message: >-\n            failed to compute the attestation manifest — see the\n            ${shellManifestModel} result data for stdout/stderr\n          severity: high\n        dependsOn:\n          - step: manifest\n            condition:\n              type: succeeded\n        weight: 0\n        allowFailure: false\n    dependsOn: []\n    weight: 0\nversion: 1\n`,\n    });\n\n    const packageManager = project.package.packageManager;\n    const actionVersions = resolveActionVersions(options.actionVersions);\n\n    new YamlFile(project, '.github/workflows/verify-attestation.yml', {\n      marker: true,\n      readonly: true,\n      obj: {\n        name: 'Verify Attestation',\n        on: {\n          pull_request: {\n            types: ['opened', 'synchronize', 'reopened'],\n          },\n        },\n        permissions: {\n          'contents': 'read',\n          'pull-requests': 'read',\n        },\n        jobs: {\n          verify: {\n            'runs-on': 'ubuntu-latest',\n            'steps': [\n              {\n                name: 'Checkout',\n                uses: actionVersions.checkout,\n                with: {\n                  'ref': '${{ github.event.pull_request.head.sha }}',\n                  'persist-credentials': false,\n                },\n              },\n              ...(packageManager === NodePackageManager.PNPM ? [{\n                name: 'Setup pnpm',\n                uses: actionVersions.pnpmActionSetup,\n              }] : []),\n              {\n                name: 'Setup Node.js',\n                uses: actionVersions.setupNode,\n                with: {\n                  'node-version': '24',\n                  'package-manager-cache': false,\n                },\n              },\n              {\n                name: 'Install dependencies',\n                run: installCommand(packageManager),\n              },\n              {\n                name: 'Fetch PR body',\n                env: {\n                  GH_TOKEN: '${{ secrets.GITHUB_TOKEN }}',\n                },\n                run: [\n                  'gh pr view ${{ github.event.pull_request.number }} \\\\',\n                  '  --repo ${{ github.repository }} \\\\',\n                  '  --json body -q .body > /tmp/pr-body.md',\n                ].join('\\n'),\n              },\n              {\n                name: 'Verify attestation',\n                run: [\n                  `${runScriptCommand(packageManager, 'attestation:verify')} -- \\\\`,\n                  '  --body-file /tmp/pr-body.md \\\\',\n                  '  --commit ${{ github.event.pull_request.head.sha }}',\n                ].join('\\n'),\n              },\n            ],\n          },\n        },\n      },\n    });\n  }\n}\n"]}

package/lib/StagingDeployWorkflow.js

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

package/lib/WorkflowAutoDiscover.js

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

package/lib/utils.d.ts

@@ -18,5 +18,20 @@ export declare function installCommand(packageManager: NodePackageManager): stri
  * name for a given branch.
  */
 export declare function sanitizeBranchNameScript(): string[];
+/**
+ * Joins commands with `;` instead of `&&`/`||` so the result is valid for a swamp
+ * command/shell model's `run:` value on both POSIX shells and Windows PowerShell 5.1
+ * (which has no `&&`/`||` chain operators before pwsh 7). Unlike `&&`, `;` does not
+ * short-circuit on failure — callers that need failure to stop the sequence should split
+ * into separate workflow steps with their own `assert` gates instead of relying on this
+ * for control flow.
+ */
+export declare function shellPortableSequence(...commands: string[]): string;
+/**
+ * Renders a portable force-delete for a single file, for use in a swamp command/shell
+ * model's `run:` value in place of `rm -f <path>` (ambiguous with PowerShell 5.1's
+ * `Remove-Item -Filter` alias). Matches the fix already validated in exman#136.
+ */
+export declare function shellPortableForceDelete(path: string): string;
 export declare function serializeTs(value: any, depth?: number): string;
 export declare function readmeContents(projectName: string, e2eTesting?: boolean, packageManager?: NodePackageManager): string;