@macedon-technologies/batman 1.34.0 → 1.35.0

package/lib/SoftwareFactoryBootstrap.js

@@ -1,15 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SoftwareFactoryBootstrap = void 0;
+exports.SoftwareFactoryBootstrap = exports.REQUIRED_EXTENSIONS_PATH = void 0;
 const projen_1 = require("projen");
+const WorkItemSource_1 = require("./WorkItemSource");
+exports.REQUIRED_EXTENSIONS_PATH = 'swamp-bootstrap/required-extensions.json';
+const SOURCE_EXTENSIONS = {
+    [WorkItemSource_1.WorkItemSource.GITHUB]: ['@webframp/github', '2026.09.08.1'],
+};
 /**
  * The extension step of `swamp:bootstrap`: a Node script, so it runs the same
  * under projen's PowerShell 5.1 task shell on Windows as under bash/sh, that
- * pulls every extension at the version pinned in the repo's swamp lockfile.
- * Fully generic — no per-repo parameterization.
+ * pulls every extension at the version pinned in the repo's swamp lockfile,
+ * then raises any extension below the minimum the enabled work-item sources
+ * need. The script is the same for every project; the minimums come from the
+ * generated `required-extensions.json`.
  */
 class SoftwareFactoryBootstrap {
-    constructor(project) {
+    constructor(project, options) {
+        new projen_1.JsonFile(project, exports.REQUIRED_EXTENSIONS_PATH, {
+            marker: true,
+            readonly: true,
+            obj: Object.fromEntries(options.workItemSources.flatMap((source) => {
+                const extension = SOURCE_EXTENSIONS[source];
+                return extension ? [extension] : [];
+            })),
+        });
         new projen_1.TextFile(project, 'swamp-bootstrap/pull-extensions.ts', {
             marker: true,
             lines: [
@@ -24,11 +39,18 @@ class SoftwareFactoryBootstrap {
                 ' * it writes backslash paths and deletes the committed files it tracks (e.g.',
                 ' * .claude/skills/software-factory/). So afterwards the lockfile and every',
                 ' * git-tracked file it lists are restored from git.',
+                ' *',
+                ' * Then each extension in swamp-bootstrap/required-extensions.json that the',
+                ' * lockfile lacks, or pins below the listed minimum, is pulled at that',
+                ' * minimum. The tracked files it lists are restored again, except the',
+                ' * lockfile, whose paths are normalized to forward slashes so it is the only',
+                ' * change left to commit.',
                 ' */',
                 "import { execFileSync } from 'node:child_process';",
-                "import { existsSync, readFileSync } from 'node:fs';",
+                "import { existsSync, readFileSync, writeFileSync } from 'node:fs';",
                 '',
                 "const LOCKFILE = 'extensions/models/upstream_extensions.json';",
+                "const REQUIRED_EXTENSIONS = 'swamp-bootstrap/required-extensions.json';",
                 "const DEFAULT_EXTENSIONS = ['@swamp/software-factory', '@webframp/github', '@goodcraft/github'];",
                 '',
                 'interface LockfileEntry {',
@@ -52,12 +74,45 @@ class SoftwareFactoryBootstrap {
                 "  execFileSync('swamp', ['extension', 'pull', extension, '--force'], { stdio: 'inherit' });",
                 '}',
                 '',
-                'function restoreTrackedFiles(lockfile: Record<string, LockfileEntry>): void {',
+                'function readRequiredExtensions(): Record<string, string> {',
+                '  if (!existsSync(REQUIRED_EXTENSIONS)) {',
+                '    return {};',
+                '  }',
+                "  const required = JSON.parse(readFileSync(REQUIRED_EXTENSIONS, 'utf8')) as Record<string, string>;",
+                "  return Object.fromEntries(Object.entries(required).filter(([name]) => name.startsWith('@')));",
+                '}',
+                '',
+                'function isOlder(version: string | undefined, minimum: string): boolean {',
+                '  for (const value of [version, minimum]) {',
+                "    if (typeof value !== 'string' || !/^\\d+(\\.\\d+)*$/.test(value)) {",
+                '      throw new Error(`Cannot compare extension version ${JSON.stringify(value)}: expected digits separated by dots`);',
+                '    }',
+                '  }',
+                "  const have = version!.split('.').map(Number);",
+                "  const want = minimum.split('.').map(Number);",
+                '  for (let i = 0; i < Math.max(have.length, want.length); i++) {',
+                '    const difference = (have[i] ?? 0) - (want[i] ?? 0);',
+                '    if (difference !== 0) {',
+                '      return difference < 0;',
+                '    }',
+                '  }',
+                '  return false;',
+                '}',
+                '',
+                'function toPosix(file: string): string {',
+                "  return file.replace(/\\\\/g, '/');",
+                '}',
+                '',
+                'function restoreTrackedFiles(lockfile: Record<string, LockfileEntry>, includeLockfile = true): void {',
                 '  const listed = Object.values(lockfile)',
                 '    .flatMap((entry) => entry.files ?? [])',
-                "    .map((file) => file.replace(/\\\\/g, '/'))",
+                '    .map(toPosix)',
                 "    .filter((file) => !file.startsWith('.swamp/'));",
-                "  const tracked = run('git', ['ls-files', '-z', '--', LOCKFILE, ...listed])",
+                '  const paths = [...(includeLockfile ? [LOCKFILE] : []), ...listed];',
+                '  if (paths.length === 0) {',
+                '    return;',
+                '  }',
+                "  const tracked = run('git', ['ls-files', '-z', '--', ...paths])",
                 "    .split('\\0')",
                 '    .filter(Boolean);',
                 '  if (tracked.length > 0) {',
@@ -66,18 +121,47 @@ class SoftwareFactoryBootstrap {
                 '  }',
                 '}',
                 '',
+                'function normalizeLockfile(lockfile: Record<string, LockfileEntry>): void {',
+                '  for (const entry of Object.values(lockfile)) {',
+                '    if (entry.files) {',
+                '      entry.files = entry.files.map(toPosix);',
+                '    }',
+                '  }',
+                '  writeFileSync(LOCKFILE, `${JSON.stringify(lockfile, null, 2)}\\n`);',
+                '}',
+                '',
+                'function pullRequiredExtensions(): void {',
+                '  const lockfile = readLockfile() ?? {};',
+                '  const needed = Object.entries(readRequiredExtensions())',
+                '    .filter(([name, minimum]) => !lockfile[name] || isOlder(lockfile[name].version, minimum));',
+                '  if (needed.length === 0) {',
+                '    return;',
+                '  }',
+                '  for (const [name, minimum] of needed) {',
+                '    pull(`${name}@${minimum}`);',
+                '  }',
+                '  const updated = readLockfile();',
+                '  if (updated) {',
+                '    const pulled = new Set(needed.map(([name]) => name));',
+                '    restoreTrackedFiles(Object.fromEntries(Object.entries(updated).filter(([name]) => !pulled.has(name))), false);',
+                '    normalizeLockfile(updated);',
+                '  }',
+                "  const pinned = needed.map(([name, minimum]) => `${name}@${minimum}`).join(', ');",
+                '  console.log(`Commit ${LOCKFILE}: it now pins ${pinned}`);',
+                '}',
+                '',
                 'function main(): void {',
                 '  const lockfile = readLockfile();',
                 '  if (!lockfile) {',
                 '    console.log(`No ${LOCKFILE} yet: pulling the latest stable software-factory extensions`);',
                 '    DEFAULT_EXTENSIONS.forEach(pull);',
-                '    return;',
-                '  }',
-                '',
-                '  for (const [name, entry] of Object.entries(lockfile)) {',
-                '    pull(`${name}@${entry.version}`);',
+                '  } else {',
+                '    for (const [name, entry] of Object.entries(lockfile)) {',
+                '      pull(`${name}@${entry.version}`);',
+                '    }',
+                '    restoreTrackedFiles(lockfile);',
                 '  }',
-                '  restoreTrackedFiles(lockfile);',
+                '  pullRequiredExtensions();',
                 '}',
                 '',
                 'main();',
@@ -98,4 +182,4 @@ class SoftwareFactoryBootstrap {
     }
 }
 exports.SoftwareFactoryBootstrap = SoftwareFactoryBootstrap;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SoftwareFactoryBootstrap.js","sourceRoot":"","sources":["../src/SoftwareFactoryBootstrap.ts"],"names":[],"mappings":"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","sourcesContent":["import { JsonFile, TextFile } from 'projen';\nimport { NodeProject } from 'projen/lib/javascript';\nimport { WorkItemSource } from './WorkItemSource';\n\nexport const REQUIRED_EXTENSIONS_PATH = 'swamp-bootstrap/required-extensions.json';\n\nconst SOURCE_EXTENSIONS: Partial<Record<WorkItemSource, [string, string]>> = {\n  [WorkItemSource.GITHUB]: ['@webframp/github', '2026.09.08.1'],\n};\n\nexport interface SoftwareFactoryBootstrapOptions {\n  /**\n   * The enabled work-item sources, whose extensions bootstrap keeps at or\n   * above their minimum versions.\n   */\n  readonly workItemSources: WorkItemSource[];\n}\n\n/**\n * The extension step of `swamp:bootstrap`: a Node script, so it runs the same\n * under projen's PowerShell 5.1 task shell on Windows as under bash/sh, that\n * pulls every extension at the version pinned in the repo's swamp lockfile,\n * then raises any extension below the minimum the enabled work-item sources\n * need. The script is the same for every project; the minimums come from the\n * generated `required-extensions.json`.\n */\nexport class SoftwareFactoryBootstrap {\n  constructor(project: NodeProject, options: SoftwareFactoryBootstrapOptions) {\n    new JsonFile(project, REQUIRED_EXTENSIONS_PATH, {\n      marker: true,\n      readonly: true,\n      obj: Object.fromEntries(options.workItemSources.flatMap((source) => {\n        const extension = SOURCE_EXTENSIONS[source];\n        return extension ? [extension] : [];\n      })),\n    });\n\n    new TextFile(project, 'swamp-bootstrap/pull-extensions.ts', {\n      marker: true,\n      lines: [\n        '/**',\n        ' * Pulls each swamp extension at the version pinned in',\n        ' * extensions/models/upstream_extensions.json, so a fresh clone runs the',\n        ' * same extensions as the rest of the team, including any the repo added',\n        ' * itself. A repo with no lockfile yet pulls DEFAULT_EXTENSIONS at their',\n        ' * latest stable versions, which creates the lockfile.',\n        ' *',\n        ' * A pull rewrites the lockfile even at an identical version, and on Windows',\n        ' * it writes backslash paths and deletes the committed files it tracks (e.g.',\n        ' * .claude/skills/software-factory/). So afterwards the lockfile and every',\n        ' * git-tracked file it lists are restored from git.',\n        ' *',\n        ' * Then each extension in swamp-bootstrap/required-extensions.json that the',\n        ' * lockfile lacks, or pins below the listed minimum, is pulled at that',\n        ' * minimum. The tracked files it lists are restored again, except the',\n        ' * lockfile, whose paths are normalized to forward slashes so it is the only',\n        ' * change left to commit.',\n        ' */',\n        \"import { execFileSync } from 'node:child_process';\",\n        \"import { existsSync, readFileSync, writeFileSync } from 'node:fs';\",\n        '',\n        \"const LOCKFILE = 'extensions/models/upstream_extensions.json';\",\n        \"const REQUIRED_EXTENSIONS = 'swamp-bootstrap/required-extensions.json';\",\n        \"const DEFAULT_EXTENSIONS = ['@swamp/software-factory', '@webframp/github', '@goodcraft/github'];\",\n        '',\n        'interface LockfileEntry {',\n        '  version: string;',\n        '  files?: string[];',\n        '}',\n        '',\n        'function readLockfile(): Record<string, LockfileEntry> | undefined {',\n        '  if (!existsSync(LOCKFILE)) {',\n        '    return undefined;',\n        '  }',\n        \"  return JSON.parse(readFileSync(LOCKFILE, 'utf8')) as Record<string, LockfileEntry>;\",\n        '}',\n        '',\n        'function run(command: string, args: string[]): string {',\n        \"  return execFileSync(command, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'inherit'] });\",\n        '}',\n        '',\n        'function pull(extension: string): void {',\n        '  console.log(`swamp extension pull ${extension} --force`);',\n        \"  execFileSync('swamp', ['extension', 'pull', extension, '--force'], { stdio: 'inherit' });\",\n        '}',\n        '',\n        'function readRequiredExtensions(): Record<string, string> {',\n        '  if (!existsSync(REQUIRED_EXTENSIONS)) {',\n        '    return {};',\n        '  }',\n        \"  const required = JSON.parse(readFileSync(REQUIRED_EXTENSIONS, 'utf8')) as Record<string, string>;\",\n        \"  return Object.fromEntries(Object.entries(required).filter(([name]) => name.startsWith('@')));\",\n        '}',\n        '',\n        'function isOlder(version: string | undefined, minimum: string): boolean {',\n        '  for (const value of [version, minimum]) {',\n        \"    if (typeof value !== 'string' || !/^\\\\d+(\\\\.\\\\d+)*$/.test(value)) {\",\n        '      throw new Error(`Cannot compare extension version ${JSON.stringify(value)}: expected digits separated by dots`);',\n        '    }',\n        '  }',\n        \"  const have = version!.split('.').map(Number);\",\n        \"  const want = minimum.split('.').map(Number);\",\n        '  for (let i = 0; i < Math.max(have.length, want.length); i++) {',\n        '    const difference = (have[i] ?? 0) - (want[i] ?? 0);',\n        '    if (difference !== 0) {',\n        '      return difference < 0;',\n        '    }',\n        '  }',\n        '  return false;',\n        '}',\n        '',\n        'function toPosix(file: string): string {',\n        \"  return file.replace(/\\\\\\\\/g, '/');\",\n        '}',\n        '',\n        'function restoreTrackedFiles(lockfile: Record<string, LockfileEntry>, includeLockfile = true): void {',\n        '  const listed = Object.values(lockfile)',\n        '    .flatMap((entry) => entry.files ?? [])',\n        '    .map(toPosix)',\n        \"    .filter((file) => !file.startsWith('.swamp/'));\",\n        '  const paths = [...(includeLockfile ? [LOCKFILE] : []), ...listed];',\n        '  if (paths.length === 0) {',\n        '    return;',\n        '  }',\n        \"  const tracked = run('git', ['ls-files', '-z', '--', ...paths])\",\n        \"    .split('\\\\0')\",\n        '    .filter(Boolean);',\n        '  if (tracked.length > 0) {',\n        \"    run('git', ['checkout', '--', ...tracked]);\",\n        '    console.log(`Restored ${tracked.length} tracked file(s) from git`);',\n        '  }',\n        '}',\n        '',\n        'function normalizeLockfile(lockfile: Record<string, LockfileEntry>): void {',\n        '  for (const entry of Object.values(lockfile)) {',\n        '    if (entry.files) {',\n        '      entry.files = entry.files.map(toPosix);',\n        '    }',\n        '  }',\n        '  writeFileSync(LOCKFILE, `${JSON.stringify(lockfile, null, 2)}\\\\n`);',\n        '}',\n        '',\n        'function pullRequiredExtensions(): void {',\n        '  const lockfile = readLockfile() ?? {};',\n        '  const needed = Object.entries(readRequiredExtensions())',\n        '    .filter(([name, minimum]) => !lockfile[name] || isOlder(lockfile[name].version, minimum));',\n        '  if (needed.length === 0) {',\n        '    return;',\n        '  }',\n        '  for (const [name, minimum] of needed) {',\n        '    pull(`${name}@${minimum}`);',\n        '  }',\n        '  const updated = readLockfile();',\n        '  if (updated) {',\n        '    const pulled = new Set(needed.map(([name]) => name));',\n        '    restoreTrackedFiles(Object.fromEntries(Object.entries(updated).filter(([name]) => !pulled.has(name))), false);',\n        '    normalizeLockfile(updated);',\n        '  }',\n        \"  const pinned = needed.map(([name, minimum]) => `${name}@${minimum}`).join(', ');\",\n        '  console.log(`Commit ${LOCKFILE}: it now pins ${pinned}`);',\n        '}',\n        '',\n        'function main(): void {',\n        '  const lockfile = readLockfile();',\n        '  if (!lockfile) {',\n        '    console.log(`No ${LOCKFILE} yet: pulling the latest stable software-factory extensions`);',\n        '    DEFAULT_EXTENSIONS.forEach(pull);',\n        '  } else {',\n        '    for (const [name, entry] of Object.entries(lockfile)) {',\n        '      pull(`${name}@${entry.version}`);',\n        '    }',\n        '    restoreTrackedFiles(lockfile);',\n        '  }',\n        '  pullRequiredExtensions();',\n        '}',\n        '',\n        'main();',\n      ],\n    });\n\n    new JsonFile(project, 'swamp-bootstrap/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

@@ -1,5 +1,6 @@
 import { NodeProject } from 'projen/lib/javascript';
 import { WorkflowActionVersions } from './WorkflowActionVersions';
+import { WorkItemSourcesOptions } from './WorkItemSource';
 export interface SoftwareFactoryFilesOptions {
     /**
      * The bare repo name (e.g. `expense-tracker`), used to derive the factory's
@@ -33,6 +34,14 @@ export interface SoftwareFactoryFilesOptions {
      * @default - only the default files
      */
     readonly attestationFiles?: string[];
+    /**
+     * The trackers the factory's intake resolves work items from. Only the
+     * sources given are enabled, so `{ jira: {...} }` means Jira alone; leave a
+     * source out to turn it off.
+     *
+     * @default { github: {} }
+     */
+    readonly workItemSources?: WorkItemSourcesOptions;
 }
 /**
  * Backports exman's swamp "software factory" pattern
@@ -59,5 +68,9 @@ export interface SoftwareFactoryFilesOptions {
  * workflows that wire them together) is templated.
  */
 export declare class SoftwareFactoryFiles {
+    /**
+     * The work-item sources a project gets when it doesn't set `workItemSources`.
+     */
+    static readonly DEFAULT_WORK_ITEM_SOURCES: WorkItemSourcesOptions;
     constructor(project: NodeProject, options: SoftwareFactoryFilesOptions);
 }

package/lib/SoftwareFactoryFiles.js

@@ -5,10 +5,12 @@ const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const SoftwareFactoryArchitectureRules_1 = require("./SoftwareFactoryArchitectureRules");
 const SoftwareFactoryAttestation_1 = require("./SoftwareFactoryAttestation");
 const SoftwareFactoryBootstrap_1 = require("./SoftwareFactoryBootstrap");
+const SoftwareFactoryJiraExtension_1 = require("./SoftwareFactoryJiraExtension");
 const SoftwareFactoryModels_1 = require("./SoftwareFactoryModels");
 const SoftwareFactoryOpenSpecGates_1 = require("./SoftwareFactoryOpenSpecGates");
 const SoftwareFactoryWorkflows_1 = require("./SoftwareFactoryWorkflows");
 const SoftwareFactoryWorkItemSources_1 = require("./SoftwareFactoryWorkItemSources");
+const WorkItemSource_1 = require("./WorkItemSource");
 const DEFAULT_GITHUB_OWNER = 'macedon-technologies';
 /**
  * Backports exman's swamp "software factory" pattern
@@ -35,9 +37,16 @@ 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.34.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@macedon-technologies/batman.SoftwareFactoryFiles", version: "1.35.0" };
+    /**
+     * The work-item sources a project gets when it doesn't set `workItemSources`.
+     */
+    static DEFAULT_WORK_ITEM_SOURCES = { github: {} };
     constructor(project, options) {
         const { repoName, actionVersions, attestationFiles } = options;
+        const workItemSources = (0, WorkItemSource_1.resolveWorkItemSources)(options.workItemSources ?? SoftwareFactoryFiles.DEFAULT_WORK_ITEM_SOURCES);
+        const jira = options.workItemSources?.jira;
+        const jiraEnabled = workItemSources.includes(WorkItemSource_1.WorkItemSource.JIRA);
         const githubOwner = options.githubOwner || DEFAULT_GITHUB_OWNER;
         const baseBranch = options.baseBranch || 'main';
         const secretsVault = `${repoName}-secrets`;
@@ -50,13 +59,18 @@ class SoftwareFactoryFiles {
             repoName,
             githubOwner,
             baseBranch,
+            workItemSources,
+            jira,
         });
-        new SoftwareFactoryWorkItemSources_1.SoftwareFactoryWorkItemSources(project, { repoName, githubOwner });
+        new SoftwareFactoryWorkItemSources_1.SoftwareFactoryWorkItemSources(project, { repoName, githubOwner, sources: workItemSources, jira });
+        if (jiraEnabled) {
+            new SoftwareFactoryJiraExtension_1.SoftwareFactoryJiraExtension(project);
+        }
         new SoftwareFactoryArchitectureRules_1.SoftwareFactoryArchitectureRules(project);
         new SoftwareFactoryAttestation_1.SoftwareFactoryAttestation(project, { repoName, attestationFiles });
         new SoftwareFactoryOpenSpecGates_1.SoftwareFactoryOpenSpecGates(project);
         new SoftwareFactoryWorkflows_1.SoftwareFactoryWorkflows(project, { repoName, actionVersions });
-        new SoftwareFactoryBootstrap_1.SoftwareFactoryBootstrap(project);
+        new SoftwareFactoryBootstrap_1.SoftwareFactoryBootstrap(project, { workItemSources });
         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',
@@ -83,6 +97,10 @@ class SoftwareFactoryFiles {
                 {
                     exec: `echo "Next: swamp vault put ${secretsVault} GITHUB_TOKEN --refresh-from 'gh auth token'"`,
                 },
+                ...(jiraEnabled && jira ? [
+                    { exec: `echo "Then: install acli from ${SoftwareFactoryJiraExtension_1.ACLI_INSTALL_GUIDE} and run: acli jira auth login --web"` },
+                    { exec: `echo "Then: acli jira auth status must show Site: ${jira.siteHost}. If it shows another site, run: acli jira auth switch --site ${jira.siteHost}"` },
+                ] : []),
             ],
         });
         // `swamp init` is safe to re-run (idempotent when already initialized),
@@ -104,4 +122,4 @@ class SoftwareFactoryFiles {
     }
 }
 exports.SoftwareFactoryFiles = SoftwareFactoryFiles;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SoftwareFactoryFiles.js","sourceRoot":"","sources":["../src/SoftwareFactoryFiles.ts"],"names":[],"mappings":"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","sourcesContent":["import { NodeProject } from 'projen/lib/javascript';\nimport { SoftwareFactoryArchitectureRules } from './SoftwareFactoryArchitectureRules';\nimport { SoftwareFactoryAttestation } from './SoftwareFactoryAttestation';\nimport { SoftwareFactoryBootstrap } from './SoftwareFactoryBootstrap';\nimport { SoftwareFactoryModels } from './SoftwareFactoryModels';\nimport { SoftwareFactoryOpenSpecGates } from './SoftwareFactoryOpenSpecGates';\nimport { SoftwareFactoryWorkflows } from './SoftwareFactoryWorkflows';\nimport { SoftwareFactoryWorkItemSources } from './SoftwareFactoryWorkItemSources';\nimport { WorkflowActionVersions } from './WorkflowActionVersions';\n\nconst DEFAULT_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 GitHub org/user the repo lives in.\n   *\n   * @default 'macedon-technologies'\n   */\n  readonly githubOwner?: 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   * Extra files that the PR attestation manifest also hashes, such as the\n   * project's own verification checks. Each entry is an exact file path\n   * relative to the project root, in normalized POSIX form, using only\n   * letters, digits and `._@+-`, with no `.` or `..` segment; synth fails\n   * on any other entry.\n   *\n   * @default - only the default files\n   */\n  readonly attestationFiles?: string[];\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 (at the versions pinned in the repo's\n * `extensions/models/upstream_extensions.json`) 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, the lockfile-driven\n * extension pull, 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, attestationFiles } = options;\n    const githubOwner = options.githubOwner || DEFAULT_GITHUB_OWNER;\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,\n      baseBranch,\n    });\n\n    new SoftwareFactoryWorkItemSources(project, { repoName, githubOwner });\n\n    new SoftwareFactoryArchitectureRules(project);\n\n    new SoftwareFactoryAttestation(project, { repoName, attestationFiles });\n\n    new SoftwareFactoryOpenSpecGates(project);\n\n    new SoftwareFactoryWorkflows(project, { repoName, actionVersions });\n\n    new SoftwareFactoryBootstrap(project);\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 swamp extensions at the versions pinned in extensions/models/upstream_extensions.json and create the secrets vault (swamp init itself already runs on every install)',\n      steps: [\n        { exec: 'ts-node --project swamp-bootstrap/tsconfig.json swamp-bootstrap/pull-extensions.ts' },\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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SoftwareFactoryFiles.js","sourceRoot":"","sources":["../src/SoftwareFactoryFiles.ts"],"names":[],"mappings":"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","sourcesContent":["import { NodeProject } from 'projen/lib/javascript';\nimport { SoftwareFactoryArchitectureRules } from './SoftwareFactoryArchitectureRules';\nimport { SoftwareFactoryAttestation } from './SoftwareFactoryAttestation';\nimport { SoftwareFactoryBootstrap } from './SoftwareFactoryBootstrap';\nimport { ACLI_INSTALL_GUIDE, SoftwareFactoryJiraExtension } from './SoftwareFactoryJiraExtension';\nimport { SoftwareFactoryModels } from './SoftwareFactoryModels';\nimport { SoftwareFactoryOpenSpecGates } from './SoftwareFactoryOpenSpecGates';\nimport { SoftwareFactoryWorkflows } from './SoftwareFactoryWorkflows';\nimport { SoftwareFactoryWorkItemSources } from './SoftwareFactoryWorkItemSources';\nimport { WorkflowActionVersions } from './WorkflowActionVersions';\nimport { resolveWorkItemSources, WorkItemSource, WorkItemSourcesOptions } from './WorkItemSource';\n\nconst DEFAULT_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 GitHub org/user the repo lives in.\n   *\n   * @default 'macedon-technologies'\n   */\n  readonly githubOwner?: 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   * Extra files that the PR attestation manifest also hashes, such as the\n   * project's own verification checks. Each entry is an exact file path\n   * relative to the project root, in normalized POSIX form, using only\n   * letters, digits and `._@+-`, with no `.` or `..` segment; synth fails\n   * on any other entry.\n   *\n   * @default - only the default files\n   */\n  readonly attestationFiles?: string[];\n\n  /**\n   * The trackers the factory's intake resolves work items from. Only the\n   * sources given are enabled, so `{ jira: {...} }` means Jira alone; leave a\n   * source out to turn it off.\n   *\n   * @default { github: {} }\n   */\n  readonly workItemSources?: WorkItemSourcesOptions;\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 (at the versions pinned in the repo's\n * `extensions/models/upstream_extensions.json`) 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, the lockfile-driven\n * extension pull, and the 3 swamp\n * workflows that wire them together) is templated.\n */\nexport class SoftwareFactoryFiles {\n  /**\n   * The work-item sources a project gets when it doesn't set `workItemSources`.\n   */\n  public static readonly DEFAULT_WORK_ITEM_SOURCES: WorkItemSourcesOptions = { github: {} };\n\n  constructor(project: NodeProject, options: SoftwareFactoryFilesOptions) {\n    const { repoName, actionVersions, attestationFiles } = options;\n    const workItemSources = resolveWorkItemSources(options.workItemSources ?? SoftwareFactoryFiles.DEFAULT_WORK_ITEM_SOURCES);\n    const jira = options.workItemSources?.jira;\n    const jiraEnabled = workItemSources.includes(WorkItemSource.JIRA);\n    const githubOwner = options.githubOwner || DEFAULT_GITHUB_OWNER;\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,\n      baseBranch,\n      workItemSources,\n      jira,\n    });\n\n    new SoftwareFactoryWorkItemSources(project, { repoName, githubOwner, sources: workItemSources, jira });\n\n    if (jiraEnabled) {\n      new SoftwareFactoryJiraExtension(project);\n    }\n\n    new SoftwareFactoryArchitectureRules(project);\n\n    new SoftwareFactoryAttestation(project, { repoName, attestationFiles });\n\n    new SoftwareFactoryOpenSpecGates(project);\n\n    new SoftwareFactoryWorkflows(project, { repoName, actionVersions });\n\n    new SoftwareFactoryBootstrap(project, { workItemSources });\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 swamp extensions at the versions pinned in extensions/models/upstream_extensions.json and create the secrets vault (swamp init itself already runs on every install)',\n      steps: [\n        { exec: 'ts-node --project swamp-bootstrap/tsconfig.json swamp-bootstrap/pull-extensions.ts' },\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        ...(jiraEnabled && jira ? [\n          { exec: `echo \"Then: install acli from ${ACLI_INSTALL_GUIDE} and run: acli jira auth login --web\"` },\n          { exec: `echo \"Then: acli jira auth status must show Site: ${jira.siteHost}. If it shows another site, run: acli jira auth switch --site ${jira.siteHost}\"` },\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/SoftwareFactoryJiraExtension.d.ts

@@ -0,0 +1,14 @@
+import { TextFile } from 'projen';
+import { NodeProject } from 'projen/lib/javascript';
+export declare const JIRA_EXTENSION_PATH = "extensions/models/jira.ts";
+export declare const JIRA_EXTENSION_TYPE = "@batman/jira";
+export declare const JIRA_EXTENSION_VERSION = "2026.11.09.1";
+export declare const JIRA_TEMPLATE_DIR: string;
+export declare const ACLI_INSTALL_GUIDE = "https://developer.atlassian.com/cloud/acli/guides/install-acli/";
+/**
+ * The managed swamp extension the Jira work-item source fetches with: one
+ * read-only `fetch` method that reads a work item through Atlassian's acli.
+ */
+export declare class SoftwareFactoryJiraExtension extends TextFile {
+    constructor(project: NodeProject);
+}

package/lib/SoftwareFactoryJiraExtension.js

@@ -0,0 +1,58 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoftwareFactoryJiraExtension = exports.ACLI_INSTALL_GUIDE = exports.JIRA_TEMPLATE_DIR = exports.JIRA_EXTENSION_VERSION = exports.JIRA_EXTENSION_TYPE = exports.JIRA_EXTENSION_PATH = void 0;
+const path = __importStar(require("path"));
+const projen_1 = require("projen");
+const templates_1 = require("./templates");
+exports.JIRA_EXTENSION_PATH = 'extensions/models/jira.ts';
+exports.JIRA_EXTENSION_TYPE = '@batman/jira';
+exports.JIRA_EXTENSION_VERSION = '2026.11.09.1';
+exports.JIRA_TEMPLATE_DIR = path.join(__dirname, '..', 'templates', 'jira');
+exports.ACLI_INSTALL_GUIDE = 'https://developer.atlassian.com/cloud/acli/guides/install-acli/';
+/**
+ * The managed swamp extension the Jira work-item source fetches with: one
+ * read-only `fetch` method that reads a work item through Atlassian's acli.
+ */
+class SoftwareFactoryJiraExtension extends projen_1.TextFile {
+    constructor(project) {
+        super(project, exports.JIRA_EXTENSION_PATH, {
+            lines: (0, templates_1.templateLines)(project, exports.JIRA_EXTENSION_PATH, exports.JIRA_TEMPLATE_DIR),
+            marker: true,
+        });
+    }
+}
+exports.SoftwareFactoryJiraExtension = SoftwareFactoryJiraExtension;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/SoftwareFactoryModels.d.ts

@@ -1,4 +1,5 @@
 import { NodeProject } from 'projen/lib/javascript';
+import { JiraWorkItemSourceOptions, WorkItemSource } from './WorkItemSource';
 export interface SoftwareFactoryModelsOptions {
     /**
      * The bare repo name (e.g. `expense-tracker`), used to derive model names
@@ -13,6 +14,15 @@ export interface SoftwareFactoryModelsOptions {
      * The branch the factory opens pull requests against.
      */
     readonly baseBranch: string;
+    /**
+     * The enabled work-item sources. Each source's seed model is generated only
+     * when that source is enabled.
+     */
+    readonly workItemSources: WorkItemSource[];
+    /**
+     * Settings for the Jira source, required when it is enabled.
+     */
+    readonly jira?: JiraWorkItemSourceOptions;
 }
 /**
  * Seed swamp model instances wiring the `@swamp/software-factory` state