@macedon-technologies/batman 1.17.2 → 1.18.0

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

package/lib/SoftwareFactoryFiles.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoftwareFactoryFiles = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const SoftwareFactoryArchitectureRules_1 = require("./SoftwareFactoryArchitectureRules");
+const SoftwareFactoryAttestation_1 = require("./SoftwareFactoryAttestation");
+const SoftwareFactoryModels_1 = require("./SoftwareFactoryModels");
+const SoftwareFactoryOpenSpecGates_1 = require("./SoftwareFactoryOpenSpecGates");
+const SoftwareFactoryWorkflows_1 = require("./SoftwareFactoryWorkflows");
+const GITHUB_OWNER = 'macedon-technologies';
+/**
+ * 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.
+ */
+class SoftwareFactoryFiles {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.SoftwareFactoryFiles", version: "1.18.0" };
+    constructor(project, options) {
+        const { repoName, actionVersions } = options;
+        const baseBranch = options.baseBranch || 'main';
+        const secretsVault = `${repoName}-secrets`;
+        // A single redirect only: projen's built-in cross-platform task shell
+        // (dax) rejects a command with more than one redirect (e.g. combining
+        // `>/dev/null` with `2>&1`) with "Multiple redirects are currently not
+        // supported" — confirmed by dogfooding this construct on this very repo.
+        const swampInitStep = 'command -v swamp >/dev/null && swamp init --tool claude || true';
+        new SoftwareFactoryModels_1.SoftwareFactoryModels(project, {
+            repoName,
+            githubOwner: GITHUB_OWNER,
+            baseBranch,
+        });
+        new SoftwareFactoryArchitectureRules_1.SoftwareFactoryArchitectureRules(project);
+        new SoftwareFactoryAttestation_1.SoftwareFactoryAttestation(project, { repoName });
+        new SoftwareFactoryOpenSpecGates_1.SoftwareFactoryOpenSpecGates(project);
+        new SoftwareFactoryWorkflows_1.SoftwareFactoryWorkflows(project, { repoName, actionVersions });
+        project.addTask('validate:architecture', {
+            description: 'Run the architecture rule registry (architecture-rules/rules.json) against the repo',
+            exec: 'ts-node --project architecture-rules/tsconfig.json architecture-rules/check.ts',
+        });
+        project.addTask('openspec:check-tasks-complete', {
+            description: 'Fail unless every task in the named OpenSpec change is complete (usage: -- <change-slug>)',
+            exec: 'ts-node --project openspec-gates/tsconfig.json openspec-gates/check-tasks-complete.ts',
+            receiveArgs: true,
+        });
+        project.addTask('attestation:manifest', {
+            description: 'Print SHA256 checksums of the files a PR attestation is verified against (see attestation/manifest.ts)',
+            exec: 'ts-node --project attestation/tsconfig.json attestation/manifest.ts',
+        });
+        project.addTask('attestation:verify', {
+            description: 'Verify a PR\'s embedded attestation-manifest against the current checkout (usage: -- --body-file <path> --commit <sha>)',
+            exec: 'ts-node --project attestation/tsconfig.json attestation/verify.ts',
+            receiveArgs: true,
+        });
+        project.addTask('swamp:bootstrap', {
+            description: 'One-time setup: pull the software-factory/github extensions and create the secrets vault (swamp init itself already runs on every install)',
+            steps: [
+                { exec: 'swamp extension pull @swamp/software-factory' },
+                { exec: 'swamp extension pull @webframp/github' },
+                { exec: 'swamp extension pull @goodcraft/github' },
+                { exec: `swamp vault create local_encryption ${secretsVault}` },
+                {
+                    exec: `echo "Next: swamp vault put ${secretsVault} GITHUB_TOKEN --refresh-from 'gh auth token'"`,
+                },
+            ],
+        });
+        // `swamp init` is safe to re-run (idempotent when already initialized),
+        // so every install keeps the repo initialized without a separate manual
+        // step — including on a fresh clone that hasn't run swamp:bootstrap yet.
+        project.package.installTask.exec(swampInitStep);
+        project.package.installCiTask.exec(swampInitStep);
+        // Mirrors the patterns `swamp init` itself would append to .gitignore.
+        // projen's IgnoreFile fully regenerates .gitignore from its own tracked
+        // entries on every synth, so anything `swamp init` appends out-of-band
+        // gets silently wiped by the next `npx projen` run (caught by CI's
+        // self-mutation check) unless it's also added here.
+        project.addGitIgnore('.swamp/');
+        project.addGitIgnore('.swamp-sources.yaml');
+        project.addGitIgnore('.claude/worktrees/');
+        project.addGitIgnore('.claude/settings.local.json');
+        project.addGitIgnore('.claude/scheduled_tasks.lock');
+        project.addGitIgnore('.claude/scheduled_tasks.json');
+    }
+}
+exports.SoftwareFactoryFiles = SoftwareFactoryFiles;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SoftwareFactoryFiles.js","sourceRoot":"","sources":["../src/SoftwareFactoryFiles.ts"],"names":[],"mappings":";;;;AACA,yFAAsF;AACtF,6EAA0E;AAC1E,mEAAgE;AAChE,iFAA8E;AAC9E,yEAAsE;AAGtE,MAAM,YAAY,GAAG,sBAAsB,CAAC;AAuB5C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAa,oBAAoB;;IAC/B,YAAY,OAAoB,EAAE,OAAoC;QACpE,MAAM,EAAE,QAAQ,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC;QAC7C,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,MAAM,CAAC;QAChD,MAAM,YAAY,GAAG,GAAG,QAAQ,UAAU,CAAC;QAC3C,sEAAsE;QACtE,sEAAsE;QACtE,uEAAuE;QACvE,yEAAyE;QACzE,MAAM,aAAa,GAAG,iEAAiE,CAAC;QAExF,IAAI,6CAAqB,CAAC,OAAO,EAAE;YACjC,QAAQ;YACR,WAAW,EAAE,YAAY;YACzB,UAAU;SACX,CAAC,CAAC;QAEH,IAAI,mEAAgC,CAAC,OAAO,CAAC,CAAC;QAE9C,IAAI,uDAA0B,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;QAEtD,IAAI,2DAA4B,CAAC,OAAO,CAAC,CAAC;QAE1C,IAAI,mDAAwB,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC,CAAC;QAEpE,OAAO,CAAC,OAAO,CAAC,uBAAuB,EAAE;YACvC,WAAW,EAAE,qFAAqF;YAClG,IAAI,EAAE,gFAAgF;SACvF,CAAC,CAAC;QAEH,OAAO,CAAC,OAAO,CAAC,+BAA+B,EAAE;YAC/C,WAAW,EAAE,2FAA2F;YACxG,IAAI,EAAE,uFAAuF;YAC7F,WAAW,EAAE,IAAI;SAClB,CAAC,CAAC;QAEH,OAAO,CAAC,OAAO,CAAC,sBAAsB,EAAE;YACtC,WAAW,EAAE,wGAAwG;YACrH,IAAI,EAAE,qEAAqE;SAC5E,CAAC,CAAC;QAEH,OAAO,CAAC,OAAO,CAAC,oBAAoB,EAAE;YACpC,WAAW,EAAE,yHAAyH;YACtI,IAAI,EAAE,mEAAmE;YACzE,WAAW,EAAE,IAAI;SAClB,CAAC,CAAC;QAEH,OAAO,CAAC,OAAO,CAAC,iBAAiB,EAAE;YACjC,WAAW,EAAE,4IAA4I;YACzJ,KAAK,EAAE;gBACL,EAAE,IAAI,EAAE,8CAA8C,EAAE;gBACxD,EAAE,IAAI,EAAE,uCAAuC,EAAE;gBACjD,EAAE,IAAI,EAAE,wCAAwC,EAAE;gBAClD,EAAE,IAAI,EAAE,uCAAuC,YAAY,EAAE,EAAE;gBAC/D;oBACE,IAAI,EAAE,+BAA+B,YAAY,+CAA+C;iBACjG;aACF;SACF,CAAC,CAAC;QAEH,wEAAwE;QACxE,wEAAwE;QACxE,yEAAyE;QACzE,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAChD,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAElD,uEAAuE;QACvE,wEAAwE;QACxE,uEAAuE;QACvE,mEAAmE;QACnE,oDAAoD;QACpD,OAAO,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;QAChC,OAAO,CAAC,YAAY,CAAC,qBAAqB,CAAC,CAAC;QAC5C,OAAO,CAAC,YAAY,CAAC,oBAAoB,CAAC,CAAC;QAC3C,OAAO,CAAC,YAAY,CAAC,6BAA6B,CAAC,CAAC;QACpD,OAAO,CAAC,YAAY,CAAC,8BAA8B,CAAC,CAAC;QACrD,OAAO,CAAC,YAAY,CAAC,8BAA8B,CAAC,CAAC;IACvD,CAAC;;AA7EH,oDA8EC","sourcesContent":["import { NodeProject } from 'projen/lib/javascript';\nimport { SoftwareFactoryArchitectureRules } from './SoftwareFactoryArchitectureRules';\nimport { SoftwareFactoryAttestation } from './SoftwareFactoryAttestation';\nimport { SoftwareFactoryModels } from './SoftwareFactoryModels';\nimport { SoftwareFactoryOpenSpecGates } from './SoftwareFactoryOpenSpecGates';\nimport { SoftwareFactoryWorkflows } from './SoftwareFactoryWorkflows';\nimport { WorkflowActionVersions } from './WorkflowActionVersions';\n\nconst GITHUB_OWNER = 'macedon-technologies';\n\nexport interface SoftwareFactoryFilesOptions {\n  /**\n   * The bare repo name (e.g. `expense-tracker`), used to derive the factory's\n   * model names (`<repoName>-factory`, `<repoName>-issues`, `<repoName>-pr`,\n   * `<repoName>-shell*`) and vault name (`<repoName>-secrets`).\n   */\n  readonly repoName: string;\n\n  /**\n   * The branch the factory opens pull requests against.\n   *\n   * @default 'main'\n   */\n  readonly baseBranch?: string;\n\n  /**\n   * Overrides for the pinned action versions used by `verify-attestation.yml`.\n   */\n  readonly actionVersions?: WorkflowActionVersions;\n}\n\n/**\n * Backports exman's swamp \"software factory\" pattern\n * (macedon-technologies/exman#13) as generated scaffolding: a\n * `@swamp/software-factory` state machine that drives a GitHub issue from\n * intake through an opened PR, enforcing OpenSpec usage, an architecture\n * rule registry, and a pre-PR verification gate whose attestation is\n * re-checked at merge time.\n *\n * What swamp itself would generate (extension docs pulled via\n * `swamp extension pull`, `.swamp.yaml`, the vault, and the \"swamp managed\n * section\" in CLAUDE.md) is deliberately NOT hand-templated here — those are\n * produced by the real `swamp` CLI. `swamp init` is idempotent (a no-op if\n * the repo is already initialized), so it's wired into the project's\n * `install`/`install:ci` tasks and runs automatically on every install,\n * guarded so it's a silent no-op on a machine without `swamp` on PATH (e.g.\n * CI). The extension pulls and vault creation are one-time, not idempotent\n * in a way that's safe to repeat on every install, so they stay in the\n * `swamp:bootstrap` task this construct adds. Only exman's own authored\n * config (the factory's state machine, the architecture-rule engine, the\n * attestation mechanism, the OpenSpec task-completion gate, and the 3 swamp\n * workflows that wire them together) is templated.\n */\nexport class SoftwareFactoryFiles {\n  constructor(project: NodeProject, options: SoftwareFactoryFilesOptions) {\n    const { repoName, actionVersions } = options;\n    const baseBranch = options.baseBranch || 'main';\n    const secretsVault = `${repoName}-secrets`;\n    // A single redirect only: projen's built-in cross-platform task shell\n    // (dax) rejects a command with more than one redirect (e.g. combining\n    // `>/dev/null` with `2>&1`) with \"Multiple redirects are currently not\n    // supported\" — confirmed by dogfooding this construct on this very repo.\n    const swampInitStep = 'command -v swamp >/dev/null && swamp init --tool claude || true';\n\n    new SoftwareFactoryModels(project, {\n      repoName,\n      githubOwner: GITHUB_OWNER,\n      baseBranch,\n    });\n\n    new SoftwareFactoryArchitectureRules(project);\n\n    new SoftwareFactoryAttestation(project, { repoName });\n\n    new SoftwareFactoryOpenSpecGates(project);\n\n    new SoftwareFactoryWorkflows(project, { repoName, actionVersions });\n\n    project.addTask('validate:architecture', {\n      description: 'Run the architecture rule registry (architecture-rules/rules.json) against the repo',\n      exec: 'ts-node --project architecture-rules/tsconfig.json architecture-rules/check.ts',\n    });\n\n    project.addTask('openspec:check-tasks-complete', {\n      description: 'Fail unless every task in the named OpenSpec change is complete (usage: -- <change-slug>)',\n      exec: 'ts-node --project openspec-gates/tsconfig.json openspec-gates/check-tasks-complete.ts',\n      receiveArgs: true,\n    });\n\n    project.addTask('attestation:manifest', {\n      description: 'Print SHA256 checksums of the files a PR attestation is verified against (see attestation/manifest.ts)',\n      exec: 'ts-node --project attestation/tsconfig.json attestation/manifest.ts',\n    });\n\n    project.addTask('attestation:verify', {\n      description: 'Verify a PR\\'s embedded attestation-manifest against the current checkout (usage: -- --body-file <path> --commit <sha>)',\n      exec: 'ts-node --project attestation/tsconfig.json attestation/verify.ts',\n      receiveArgs: true,\n    });\n\n    project.addTask('swamp:bootstrap', {\n      description: 'One-time setup: pull the software-factory/github extensions and create the secrets vault (swamp init itself already runs on every install)',\n      steps: [\n        { exec: 'swamp extension pull @swamp/software-factory' },\n        { exec: 'swamp extension pull @webframp/github' },\n        { exec: 'swamp extension pull @goodcraft/github' },\n        { exec: `swamp vault create local_encryption ${secretsVault}` },\n        {\n          exec: `echo \"Next: swamp vault put ${secretsVault} GITHUB_TOKEN --refresh-from 'gh auth token'\"`,\n        },\n      ],\n    });\n\n    // `swamp init` is safe to re-run (idempotent when already initialized),\n    // so every install keeps the repo initialized without a separate manual\n    // step — including on a fresh clone that hasn't run swamp:bootstrap yet.\n    project.package.installTask.exec(swampInitStep);\n    project.package.installCiTask.exec(swampInitStep);\n\n    // Mirrors the patterns `swamp init` itself would append to .gitignore.\n    // projen's IgnoreFile fully regenerates .gitignore from its own tracked\n    // entries on every synth, so anything `swamp init` appends out-of-band\n    // gets silently wiped by the next `npx projen` run (caught by CI's\n    // self-mutation check) unless it's also added here.\n    project.addGitIgnore('.swamp/');\n    project.addGitIgnore('.swamp-sources.yaml');\n    project.addGitIgnore('.claude/worktrees/');\n    project.addGitIgnore('.claude/settings.local.json');\n    project.addGitIgnore('.claude/scheduled_tasks.lock');\n    project.addGitIgnore('.claude/scheduled_tasks.json');\n  }\n}\n"]}

package/lib/SoftwareFactoryModels.d.ts

@@ -0,0 +1,25 @@
+import { NodeProject } from 'projen/lib/javascript';
+export interface SoftwareFactoryModelsOptions {
+    /**
+     * The bare repo name (e.g. `expense-tracker`), used to derive model names
+     * like `<repoName>-factory`, `<repoName>-shell`, `<repoName>-secrets`.
+     */
+    readonly repoName: string;
+    /**
+     * The GitHub org the repo lives in.
+     */
+    readonly githubOwner: string;
+    /**
+     * The branch the factory opens pull requests against.
+     */
+    readonly baseBranch: string;
+}
+/**
+ * Seed swamp model instances wiring the `@swamp/software-factory` state
+ * machine to this repo's GitHub issues/PRs and shell steps. These are
+ * `SampleFile`s (written once, then owned by the team) since the factory's
+ * stages/gates are the kind of thing a team tunes for its own workflow.
+ */
+export declare class SoftwareFactoryModels {
+    constructor(project: NodeProject, options: SoftwareFactoryModelsOptions);
+}