pipecraft 0.29.3 → 0.36.2

package/dist/templates/release-it.cjs.tpl.js

@@ -12,7 +12,7 @@
  *
  * @module templates/release-it.cjs.tpl
  */
-import { toFile, renderTemplate } from '@featherscloud/pinion';
+import { renderTemplate, toFile } from '@featherscloud/pinion';
 import { logger } from '../utils/logger.js';
 /**
  * Generate release-it configuration content
@@ -26,32 +26,30 @@ import { logger } from '../utils/logger.js';
  * @returns {string} JavaScript configuration content
  */
 const releaseItTemplate = (ctx) => {
-    const bumpRules = ctx.semver?.bumpRules || {
-        feat: 'minor',
+    // Base default prefixes for conventional commits
+    const baseDefaults = {
+        test: 'ignore',
+        build: 'ignore',
+        ci: 'patch',
+        docs: 'patch',
+        chore: 'minor',
+        style: 'patch',
         fix: 'patch',
-        breaking: 'major'
+        perf: 'patch',
+        refactor: 'patch',
+        feat: 'minor',
+        major: 'major'
     };
-    // Convert bump rules to release-it format
-    const releaseItTypes = Object.entries(bumpRules).map(([type, level]) => {
-        const releaseItLevel = level === 'major' ? 'major' :
-            level === 'minor' ? 'minor' :
-                level === 'patch' ? 'patch' : 'ignore';
-        return `              ${type}: '${releaseItLevel}'`;
-    }).join(',\n');
+    // Get user-defined bump rules from config
+    const userBumpRules = ctx.config?.semver?.bumpRules || ctx.semver?.bumpRules || {};
+    // Merge user rules with defaults (user rules take precedence)
+    const mergedRules = { ...baseDefaults, ...userBumpRules };
+    // Convert to formatted string for the config file
+    const rulesEntries = Object.entries(mergedRules)
+        .map(([type, level]) => `  ${type}: '${level}'`)
+        .join(',\n');
     return `const DEFAULT_PREFIXES = {
-  test: 'ignore',
-  build: 'ignore',
-
-  ci: 'patch',
-  docs: 'patch',
-  chore: 'minor',
-  style: 'patch',
-  fix: 'patch',
-  perf: 'patch',
-  refactor: 'patch',
-
-  feat: 'minor',
-  major: 'major',
+${rulesEntries}
 }
 
 module.exports = {
@@ -137,12 +135,12 @@ module.exports = {
  * ```
  */
 export const generate = (ctx) => Promise.resolve(ctx)
-    .then((ctx) => {
+    .then(ctx => {
     logger.verbose('📝 Generating release-it configuration...');
     return ctx;
 })
     .then(renderTemplate((ctx) => releaseItTemplate(ctx), toFile('.release-it.cjs')))
-    .then((ctx) => {
+    .then(ctx => {
     logger.verbose('✅ Generated .release-it.cjs');
     return ctx;
 });

package/dist/templates/release-it.cjs.tpl.js.map

@@ -1 +1 @@
-{"version":3,"file":"release-it.cjs.tpl.js","sourceRoot":"","sources":["../../src/templates/release-it.cjs.tpl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAiB,MAAM,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAC7E,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAE3C;;;;;;;;;;GAUG;AACH,MAAM,iBAAiB,GAAG,CAAC,GAAQ,EAAE,EAAE;IACrC,MAAM,SAAS,GAAG,GAAG,CAAC,MAAM,EAAE,SAAS,IAAI;QACzC,IAAI,EAAE,OAAO;QACb,GAAG,EAAE,OAAO;QACZ,QAAQ,EAAE,OAAO;KAClB,CAAA;IAED,0CAA0C;IAC1C,MAAM,cAAc,GAAG,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,EAAE;QACrE,MAAM,cAAc,GAAG,KAAK,KAAK,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;YAC9B,KAAK,KAAK,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;gBAC7B,KAAK,KAAK,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAA;QAC5D,OAAO,iBAAiB,IAAI,MAAM,cAAc,GAAG,CAAA;IACrD,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IAEd,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAwEL,CAAA;AACJ,CAAC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,GAAkB,EAAE,EAAE,CAC7C,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC;KACjB,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE;IACZ,MAAM,CAAC,OAAO,CAAC,2CAA2C,CAAC,CAAA;IAC3D,OAAO,GAAG,CAAA;AACZ,CAAC,CAAC;KACD,IAAI,CAAC,cAAc,CAClB,CAAC,GAAQ,EAAE,EAAE,CAAC,iBAAiB,CAAC,GAAG,CAAC,EACpC,MAAM,CAAC,iBAAiB,CAAC,CAC1B,CAAC;KACD,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE;IACZ,MAAM,CAAC,OAAO,CAAC,6BAA6B,CAAC,CAAA;IAC7C,OAAO,GAAG,CAAA;AACZ,CAAC,CAAC,CAAA"}
+{"version":3,"file":"release-it.cjs.tpl.js","sourceRoot":"","sources":["../../src/templates/release-it.cjs.tpl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAsB,cAAc,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAA;AAClF,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAE3C;;;;;;;;;;GAUG;AACH,MAAM,iBAAiB,GAAG,CAAC,GAAQ,EAAE,EAAE;IACrC,iDAAiD;IACjD,MAAM,YAAY,GAA2B;QAC3C,IAAI,EAAE,QAAQ;QACd,KAAK,EAAE,QAAQ;QACf,EAAE,EAAE,OAAO;QACX,IAAI,EAAE,OAAO;QACb,KAAK,EAAE,OAAO;QACd,KAAK,EAAE,OAAO;QACd,GAAG,EAAE,OAAO;QACZ,IAAI,EAAE,OAAO;QACb,QAAQ,EAAE,OAAO;QACjB,IAAI,EAAE,OAAO;QACb,KAAK,EAAE,OAAO;KACf,CAAA;IAED,0CAA0C;IAC1C,MAAM,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,IAAI,GAAG,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,CAAA;IAElF,8DAA8D;IAC9D,MAAM,WAAW,GAAG,EAAE,GAAG,YAAY,EAAE,GAAG,aAAa,EAAE,CAAA;IAEzD,kDAAkD;IAClD,MAAM,YAAY,GAAG,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC;SAC7C,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,IAAI,MAAM,KAAK,GAAG,CAAC;SAC/C,IAAI,CAAC,KAAK,CAAC,CAAA;IAEd,OAAO;EACP,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA2DV,CAAA;AACJ,CAAC,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,GAAkB,EAAE,EAAE,CAC7C,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC;KACjB,IAAI,CAAC,GAAG,CAAC,EAAE;IACV,MAAM,CAAC,OAAO,CAAC,2CAA2C,CAAC,CAAA;IAC3D,OAAO,GAAG,CAAA;AACZ,CAAC,CAAC;KACD,IAAI,CAAC,cAAc,CAAC,CAAC,GAAQ,EAAE,EAAE,CAAC,iBAAiB,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,iBAAiB,CAAC,CAAC,CAAC;KACrF,IAAI,CAAC,GAAG,CAAC,EAAE;IACV,MAAM,CAAC,OAAO,CAAC,6BAA6B,CAAC,CAAA;IAC7C,OAAO,GAAG,CAAA;AACZ,CAAC,CAAC,CAAA"}

package/dist/templates/workflows/enforce-pr-target.yml.tpl.d.ts

@@ -26,7 +26,7 @@
  * })
  * ```
  */
-import { PinionContext } from '@featherscloud/pinion';
+import { type PinionContext } from '@featherscloud/pinion';
 /**
  * Generates the enforce-pr-target.yml workflow file.
  *

package/dist/templates/workflows/enforce-pr-target.yml.tpl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"enforce-pr-target.yml.tpl.d.ts","sourceRoot":"","sources":["../../../src/templates/workflows/enforce-pr-target.yml.tpl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,aAAa,EAA0B,MAAM,uBAAuB,CAAA;AAE7E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,QAAQ,GAAI,KAAK,aAAa,iBAmCrC,CAAA"}
+{"version":3,"file":"enforce-pr-target.yml.tpl.d.ts","sourceRoot":"","sources":["../../../src/templates/workflows/enforce-pr-target.yml.tpl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,KAAK,aAAa,EAA0B,MAAM,uBAAuB,CAAA;AAElF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,QAAQ,GAAI,KAAK,aAAa,iBAiCxC,CAAA"}

package/dist/templates/workflows/enforce-pr-target.yml.tpl.js

@@ -26,7 +26,7 @@
  * })
  * ```
  */
-import { toFile, renderTemplate } from '@featherscloud/pinion';
+import { renderTemplate, toFile } from '@featherscloud/pinion';
 /**
  * Generates the enforce-pr-target.yml workflow file.
  *
@@ -49,8 +49,7 @@ import { toFile, renderTemplate } from '@featherscloud/pinion';
  * // Creates: .github/workflows/enforce-pr-target.yml
  * ```
  */
-export const generate = (ctx) => Promise.resolve(ctx)
-    .then(renderTemplate((ctx) => {
+export const generate = (ctx) => Promise.resolve(ctx).then(renderTemplate((ctx) => {
     const { initialBranch = 'develop', finalBranch = 'main' } = ctx;
     return `name: Enforce PR Target Branch
 

package/dist/templates/workflows/enforce-pr-target.yml.tpl.js.map

@@ -1 +1 @@
-{"version":3,"file":"enforce-pr-target.yml.tpl.js","sourceRoot":"","sources":["../../../src/templates/workflows/enforce-pr-target.yml.tpl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAiB,MAAM,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAE7E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,GAAkB,EAAE,EAAE,CAC7C,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC;KACjB,IAAI,CAAC,cAAc,CAClB,CAAC,GAAQ,EAAE,EAAE;IACX,MAAM,EAAE,aAAa,GAAG,SAAS,EAAE,WAAW,GAAG,MAAM,EAAE,GAAG,GAAG,CAAA;IAE/D,OAAO;;;;;;;;;;;kCAWmB,WAAW;;sDAES,aAAa,kBAAkB,WAAW;6DACnC,aAAa;;;;;8CAK5B,WAAW,SAAS,aAAa;;;;kCAI7C,aAAa;;0CAEL,aAAa;CACtD,CAAA;AACK,CAAC,EACD,MAAM,CAAC,yCAAyC,CAAC,CAClD,CAAC,CAAA"}
+{"version":3,"file":"enforce-pr-target.yml.tpl.js","sourceRoot":"","sources":["../../../src/templates/workflows/enforce-pr-target.yml.tpl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAsB,cAAc,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAA;AAElF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,GAAkB,EAAE,EAAE,CAC7C,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,CACvB,cAAc,CAAC,CAAC,GAAQ,EAAE,EAAE;IAC1B,MAAM,EAAE,aAAa,GAAG,SAAS,EAAE,WAAW,GAAG,MAAM,EAAE,GAAG,GAAG,CAAA;IAE/D,OAAO;;;;;;;;;;;kCAWqB,WAAW;;sDAES,aAAa,kBAAkB,WAAW;6DACnC,aAAa;;;;;8CAK5B,WAAW,SAAS,aAAa;;;;kCAI7C,aAAa;;0CAEL,aAAa;CACtD,CAAA;AACG,CAAC,EAAE,MAAM,CAAC,yCAAyC,CAAC,CAAC,CACtD,CAAA"}

package/dist/templates/workflows/pipeline-nx.yml.tpl.d.ts

@@ -7,8 +7,8 @@
  *
  * This is Option 1 (Sequential Strategy) - simple, fast, and leverages Nx's intelligence.
  */
-import { PinionContext } from '@featherscloud/pinion';
-import { PipecraftConfig } from '../../types/index.js';
+import { type PinionContext } from '@featherscloud/pinion';
+import type { PipecraftConfig } from '../../types/index.js';
 interface NxPipelineContext extends PinionContext {
     config: PipecraftConfig;
     branchFlow: string[];

package/dist/templates/workflows/pipeline-nx.yml.tpl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pipeline-nx.yml.tpl.d.ts","sourceRoot":"","sources":["../../../src/templates/workflows/pipeline-nx.yml.tpl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,aAAa,EAA0B,MAAM,uBAAuB,CAAA;AAC7E,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAiBtD,UAAU,iBAAkB,SAAQ,aAAa;IAC/C,MAAM,EAAE,eAAe,CAAA;IACvB,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B;AAqFD;;GAEG;AACH,eAAO,MAAM,QAAQ,GAAI,KAAK,iBAAiB,iBAwH2F,CAAA"}
+{"version":3,"file":"pipeline-nx.yml.tpl.d.ts","sourceRoot":"","sources":["../../../src/templates/workflows/pipeline-nx.yml.tpl.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,KAAK,aAAa,EAA0B,MAAM,uBAAuB,CAAA;AAGlF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAoB3D,UAAU,iBAAkB,SAAQ,aAAa;IAC/C,MAAM,EAAE,eAAe,CAAA;IACvB,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B;AAgHD;;GAEG;AACH,eAAO,MAAM,QAAQ,GAAI,KAAK,iBAAiB,iBA2U1C,CAAA"}

package/dist/templates/workflows/pipeline-nx.yml.tpl.js

@@ -8,86 +8,102 @@
  * This is Option 1 (Sequential Strategy) - simple, fast, and leverages Nx's intelligence.
  */
 import { renderTemplate, toFile } from '@featherscloud/pinion';
-import { parseDocument, stringify } from 'yaml';
 import fs from 'fs';
-import { logger } from '../../utils/logger.js';
+import { parseDocument, Scalar, stringify } from 'yaml';
 import { applyPathOperations, createValueFromString } from '../../utils/ast-path-operations.js';
-import { createHeaderOperations, createChangesJobOperation, createDomainTestJobOperations, createDomainDeployJobOperations, createDomainRemoteTestJobOperations, createVersionJobOperation, createTagPromoteReleaseOperations, getDomainJobNames } from './shared/index.js';
+import { logger } from '../../utils/logger.js';
 import { formatIfConditions } from '../yaml-format-utils.js';
+import { createChangesJobOperation, createGateJobOperation, createHeaderOperations, createTagPromoteReleaseOperations, createVersionJobOperation, getDomainJobNames } from './shared/index.js';
+/**
+ * Extract user-customized section between markers from YAML content
+ * Returns content WITHOUT the markers themselves
+ * Uses unique delimiters as YAML comments (indentation-independent)
+ */
+function extractUserSection(yamlContent) {
+    // Match markers as YAML comments: any leading whitespace + one or more # + optional whitespace + marker
+    // Example: "  ### <--START CUSTOM JOBS-->"
+    const startMarkerRegex = /^.*#+\s*<--START CUSTOM JOBS-->\s*$/m;
+    const endMarkerRegex = /^.*#+\s*<--END CUSTOM JOBS-->\s*$/m;
+    const startMatch = yamlContent.match(startMarkerRegex);
+    const endMatch = yamlContent.match(endMarkerRegex);
+    if (!startMatch || !endMatch) {
+        return null;
+    }
+    const startIndex = startMatch.index + startMatch[0].length;
+    const endIndex = endMatch.index;
+    // Extract content between markers (NOT including the markers themselves)
+    let extracted = yamlContent.substring(startIndex, endIndex);
+    // Normalize whitespace: remove leading/trailing newlines
+    // These will be added back consistently during insertion
+    extracted = extracted.replace(/^\n+/, '');
+    extracted = extracted.replace(/\n+$/, '');
+    return extracted;
+}
 /**
- * Create the nx-ci job operation (Nx-specific)
+ * Create the test-nx job operation (Nx-specific)
  */
-function createNxCiJobOperation(ctx) {
+function createTestNxJobOperation(ctx) {
     const { config } = ctx;
     const nxConfig = config.nx;
     const packageManager = config.packageManager || 'npm';
     const enableCache = nxConfig.enableCache !== false;
-    const taskSteps = nxConfig.tasks
-        .map(task => `      - name: Run Nx Affected - ${task}
-        run: npx nx affected --target=${task} --base=\${{ inputs.baseRef || '${nxConfig.baseRef || 'origin/main'}' }}`)
-        .join('\n');
+    const targets = nxConfig.tasks.join(',');
+    // Build the job steps
     const cacheStep = enableCache
         ? `
       - name: Cache Nx
         uses: actions/cache@v4
         with:
           path: .nx/cache
-          # Cache key includes run_number to allow saving updated cache on each run
-          # Nx cache accumulates computation results, so we want to save after every run
-          # restore-keys ensure we start from the most recent cache on this branch
-          key: nx-\${{ runner.os }}-\${{ hashFiles('package-lock.json') }}-\${{ github.ref_name }}-\${{ github.run_number }}
+          key: \${{ runner.os }}-nx-\${{ hashFiles('**/nx.json', '**/.nxignore', '**/package-lock.json', '**/pnpm-lock.yaml', '**/yarn.lock') }}
           restore-keys: |
-            nx-\${{ runner.os }}-\${{ hashFiles('package-lock.json') }}-\${{ github.ref_name }}-
-            nx-\${{ runner.os }}-\${{ hashFiles('package-lock.json') }}-
-            nx-\${{ runner.os }}-
-`
+            \${{ runner.os }}-nx-`
         : '';
+    // Build individual task steps
+    const taskSteps = nxConfig.tasks
+        .map(target => `
+      - name: Run nx affected --target=${target}
+        run: |
+          npx nx affected --target=${target} --base=\${{ inputs.baseRef || '${nxConfig.baseRef || 'origin/main'}' }} || echo "No affected projects"`)
+        .join('');
     return {
-        path: 'jobs.nx-ci',
-        operation: 'overwrite',
+        path: 'jobs.test-nx',
+        operation: 'preserve', // User can customize this job!
         commentBefore: `
 =============================================================================
-NX CI - All Tasks Sequential (⚠️  Managed by Pipecraft - do not modify)
+ TEST-NX ( ✅ Customize these with your test logic)
 =============================================================================
-This job runs all Nx tasks sequentially using \`nx affected\`.
-Nx handles dependency detection, caching, and parallel execution internally.
+ This job runs all Nx tasks sequentially using \`nx affected\`.
+ Nx handles dependency detection, caching, and parallel execution internally.
 `,
         value: createValueFromString(`
-    needs: changes
+    needs: [ changes ]
     runs-on: ubuntu-latest
     steps:
-      - name: Checkout Code
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v4
         with:
           ref: \${{ inputs.commitSha || github.sha }}
-          fetch-depth: 0
-
+          fetch-depth: \${{ env.FETCH_DEPTH_AFFECTED }}
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: '24'
-
-      - name: Install Dependencies
-        run: |
-          case "${packageManager}" in
-            pnpm)
-              corepack enable
-              pnpm install --frozen-lockfile || pnpm install
-              ;;
-            yarn)
-              yarn install --frozen-lockfile || yarn install
-              ;;
-            npm)
-              npm ci || npm install
-              ;;
-            *)
-              npm install
-              ;;
-          esac
-        env:
-          packageManager: ${packageManager}
-${cacheStep}
-${taskSteps}
+          node-version: \${{ env.NODE_VERSION }}
+      ${packageManager === 'pnpm'
+            ? `
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: \${{ env.PNPM_VERSION }}
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile`
+            : packageManager === 'yarn'
+                ? `
+      - name: Install dependencies
+        run: yarn install --frozen-lockfile`
+                : `
+      - name: Install dependencies
+        run: npm ci`}
+      ${cacheStep}${taskSteps}
   `)
     };
 }
@@ -102,7 +118,7 @@ export const generate = (ctx) => Promise.resolve(ctx)
     const nxConfig = config.nx;
     // Get domain job names for dependency management
     const { testJobs, deployJobs, remoteTestJobs } = getDomainJobNames(domains);
-    // Build operations array
+    // Build operations array - only managed jobs
     const operations = [
         // Header (name, run-name, on triggers)
         ...createHeaderOperations({ branchFlow }),
@@ -110,60 +126,202 @@ export const generate = (ctx) => Promise.resolve(ctx)
         createChangesJobOperation({
             domains,
             useNx: true,
-            baseRef: nxConfig.baseRef || 'origin/main'
+            baseRef: nxConfig.baseRef || 'origin/main',
+            config
         }),
-        // Nx CI job (Nx-specific!)
-        createNxCiJobOperation(ctx),
-        // Domain test jobs (preserved for user customization)
-        ...createDomainTestJobOperations({ domains }),
-        // Version calculation
+        // Nx test job (runs all Nx tasks)
+        createTestNxJobOperation(ctx),
+        // Version calculation (depends on test-nx and changes)
         createVersionJobOperation({
-            testJobNames: testJobs,
-            nxEnabled: true,
-            baseRef: nxConfig.baseRef || 'origin/main'
+            testJobNames: [], // No domain test job dependencies
+            nxEnabled: true, // Depends on test-nx job
+            baseRef: nxConfig.baseRef || 'origin/main',
+            config
+        }),
+        // Gate job (runs after test-nx, gates downstream jobs)
+        createGateJobOperation({
+            testJobNames: ['test-nx'], // Gate on the Nx test job
+            deployJobNames: [] // Could add deploy jobs here if needed
         }),
-        // Domain deploy jobs (preserved for user customization)
-        ...createDomainDeployJobOperations({ domains }),
-        // Domain remote test jobs (preserved for user customization)
-        ...createDomainRemoteTestJobOperations({ domains }),
         // Tag, promote, release
         ...createTagPromoteReleaseOperations({
             branchFlow,
-            deployJobNames: deployJobs,
-            remoteTestJobNames: remoteTestJobs
+            deployJobNames: [], // No deployment dependencies in new model
+            remoteTestJobNames: [],
+            testJobNames: ['test-nx'], // For Nx, the single test-nx job is the gate
+            autoMerge: typeof config.autoMerge === 'object' ? config.autoMerge : {},
+            config
         })
     ];
     // Check if file exists
-    if (!fs.existsSync(filePath)) {
-        logger.verbose('📝 Creating new Nx pipeline');
+    const fileExists = fs.existsSync(filePath);
+    // Extract user-customized section and custom jobs from existing file if it exists
+    let userSection = null;
+    const customJobsFromExisting = [];
+    if (fileExists) {
+        const existingContent = fs.readFileSync(filePath, 'utf8');
+        userSection = extractUserSection(existingContent);
+        if (userSection) {
+            logger.verbose('📋 Found user-customized section between markers');
+        }
+        // Also extract custom jobs (for force mode preservation)
+        const existingDoc = parseDocument(existingContent);
+        const existingJobs = existingDoc.contents && existingDoc.contents.get
+            ? existingDoc.contents.get('jobs')
+            : null;
+        const managedJobs = new Set([
+            'changes',
+            'version',
+            'gate',
+            'tag',
+            'promote',
+            'release',
+            'test-nx'
+        ]);
+        if (existingJobs && existingJobs.items) {
+            for (const pair of existingJobs.items) {
+                const keyStr = pair.key instanceof Scalar ? pair.key.value : pair.key;
+                if (!managedJobs.has(keyStr)) {
+                    customJobsFromExisting.push(pair);
+                }
+            }
+        }
+        if (customJobsFromExisting.length > 0) {
+            logger.verbose(`📋 Found ${customJobsFromExisting.length} custom job(s) to preserve`);
+        }
+    }
+    // In force mode or new file, create fresh document to ensure correct structure
+    if (!fileExists || ctx.pinion?.force) {
+        const logMessage = !fileExists
+            ? '📝 Creating new Nx pipeline'
+            : '🔄 Force mode: Rebuilding Nx pipeline from scratch';
+        logger.verbose(logMessage);
         // Create new document with empty YAML map
         const doc = parseDocument('{}');
+        // Ensure the root map uses block style (not flow/compact)
+        if (doc.contents && doc.contents.flow !== undefined) {
+            ;
+            doc.contents.flow = false;
+        }
+        // Add header comment block to document
+        const headerComment = `=============================================================================
+ PIPECRAFT MANAGED WORKFLOW
+=============================================================================
+
+ ✅ YOU CAN CUSTOMIZE:
+   - Custom jobs between the '# <--START CUSTOM JOBS-->' and '# <--END CUSTOM JOBS-->' comment markers
+   - Workflow name
+
+ ⚠️  PIPECRAFT MANAGES (do not modify):
+   - Workflow triggers, job dependencies, and conditionals
+   - Changes detection, version calculation, and tag creation
+   - CreatePR, branch management, promote, and release jobs
+
+ 📌 VERSION PROMOTION BEHAVIOR:
+   - Only commits that trigger a version bump will promote to staging/main
+   - Non-versioned commits (test, build, etc.) remain on develop
+   - This keeps staging/main aligned with tagged releases
+
+ Running 'pipecraft generate' updates managed sections while preserving
+ your customizations in test/deploy/smoke-test etc jobs.
+
+ 📖 Learn more: https://pipecraft.thecraftlab.dev
+=============================================================================`;
+        doc.commentBefore = headerComment;
         if (doc.contents) {
             applyPathOperations(doc.contents, operations, doc);
         }
-        const yamlContent = stringify(doc, { lineWidth: 0, minContentWidth: 0 });
+        let yamlContent = stringify(doc, {
+            lineWidth: 0, // 0 means no line width limit for scalars
+            indent: 2,
+            defaultStringType: 'PLAIN',
+            defaultKeyType: 'PLAIN',
+            minContentWidth: 0
+        });
+        // Insert user section and custom jobs after version job if they exist
+        const hasCustomContent = userSection || customJobsFromExisting.length > 0;
+        if (hasCustomContent) {
+            // Find the insertion point (after version job outputs)
+            const versionOutputsPattern = /^ {2}version:\s*\n(?:.*\n)*? {4}outputs:\s*\n\s*version:.*$/m;
+            const match = yamlContent.match(versionOutputsPattern);
+            if (match) {
+                const insertionIndex = match.index + match[0].length;
+                let contentToInsert = '';
+                // Add user section if exists
+                if (userSection) {
+                    contentToInsert += `# <--START CUSTOM JOBS-->\n\n${userSection}\n\n  # <--END CUSTOM JOBS-->`;
+                }
+                // Add custom jobs if they exist (and weren't in user section)
+                if (customJobsFromExisting.length > 0 && !userSection) {
+                    const customJobsYaml = customJobsFromExisting
+                        .map(pair => {
+                        const keyStr = pair.key instanceof Scalar ? pair.key.value : pair.key;
+                        const valueYaml = stringify(pair.value, { indent: 2 });
+                        return `  ${keyStr}:\n${valueYaml
+                            .split('\n')
+                            .map((line) => (line ? '  ' + line : line))
+                            .join('\n')}`;
+                    })
+                        .join('\n\n');
+                    contentToInsert = `# <--START CUSTOM JOBS-->\n\n${customJobsYaml}\n\n  # <--END CUSTOM JOBS-->`;
+                }
+                if (contentToInsert) {
+                    yamlContent =
+                        yamlContent.slice(0, insertionIndex) +
+                            '\n\n  ' +
+                            contentToInsert +
+                            '\n' +
+                            yamlContent.slice(insertionIndex);
+                    logger.verbose('📋 Inserted user-customized section after version job');
+                }
+            }
+            else {
+                logger.verbose('⚠️  Could not find version job outputs, appending user section at end');
+                const contentToInsert = userSection ||
+                    (customJobsFromExisting.length > 0
+                        ? customJobsFromExisting
+                            .map(pair => {
+                            const keyStr = pair.key instanceof Scalar ? pair.key.value : pair.key;
+                            const valueYaml = stringify(pair.value, { indent: 2 });
+                            return `  ${keyStr}:\n${valueYaml
+                                .split('\n')
+                                .map((line) => (line ? '  ' + line : line))
+                                .join('\n')}`;
+                        })
+                            .join('\n\n')
+                        : '');
+                const userSectionWithMarkers = `# <--START CUSTOM JOBS-->\n\n${contentToInsert}\n\n  # <--END CUSTOM JOBS-->`;
+                yamlContent = yamlContent + '\n\n  ' + userSectionWithMarkers;
+            }
+        }
+        else if (!fileExists) {
+            // For new files, add placeholder markers
+            const versionOutputsPattern = /^( {2}version:\s*\n(?:.*\n)*? {4}outputs:\s*\n\s*version:.*)$/m;
+            yamlContent = yamlContent.replace(versionOutputsPattern, '$1\n\n  # <--START CUSTOM JOBS-->\n\n  # <--END CUSTOM JOBS-->\n');
+            logger.verbose('📝 Added placeholder user section markers');
+        }
         const formattedContent = formatIfConditions(yamlContent);
-        return { ...ctx, yamlContent: formattedContent, mergeStatus: 'created' };
+        const status = hasCustomContent ? 'merged' : fileExists ? 'rebuilt' : 'created';
+        return { ...ctx, yamlContent: formattedContent, mergeStatus: status };
     }
-    // Parse existing file
+    // Parse existing file for merge mode (no force flag)
     const existingContent = fs.readFileSync(filePath, 'utf8');
     const doc = parseDocument(existingContent);
     // Get managed jobs (always overwritten)
-    const managedJobs = new Set(['changes', 'nx-ci', 'version', 'tag', 'promote', 'release']);
-    // Extract user jobs from existing (preserves comments!)
-    const userJobs = new Map();
+    const managedJobs = new Set(['changes', 'version', 'tag', 'promote', 'release', 'test-nx']);
+    // test-nx is preserved (user can customize), but still managed if it doesn't exist
+    // Extract custom jobs (not managed and not in user section between markers)
     const existingJobs = doc.contents && doc.contents.get ? doc.contents.get('jobs') : null;
+    const customJobs = [];
     if (existingJobs && existingJobs.items) {
-        for (const item of existingJobs.items) {
-            const jobName = item.key?.toString();
-            if (jobName && !managedJobs.has(jobName) && !testJobs.includes(jobName) && !deployJobs.includes(jobName) && !remoteTestJobs.includes(jobName)) {
-                // This is a custom user job - preserve it completely
-                userJobs.set(jobName, item);
+        // Preserve jobs that are not managed
+        for (const pair of existingJobs.items) {
+            const keyStr = pair.key instanceof Scalar ? pair.key.value : pair.key;
+            if (!managedJobs.has(keyStr)) {
+                customJobs.push(pair);
             }
         }
-    }
-    // Clear all jobs before applying operations to prevent duplicates
-    if (existingJobs && existingJobs.items) {
+        // Clear all jobs before applying operations to prevent duplicates
         ;
         existingJobs.items = [];
     }
@@ -171,24 +329,73 @@ export const generate = (ctx) => Promise.resolve(ctx)
     if (doc.contents) {
         applyPathOperations(doc.contents, operations, doc);
     }
-    // Add back user jobs (preserves their comments!)
-    if (userJobs.size > 0) {
-        logger.verbose(`📋 Preserving ${userJobs.size} user jobs: ${Array.from(userJobs.keys()).join(', ')}`);
-        const jobsNode = doc.contents.get('jobs');
-        if (jobsNode && jobsNode.items) {
-            for (const [_, item] of userJobs) {
-                jobsNode.items.push(item);
-            }
+    // Reinsert custom jobs (preserved from existing pipeline)
+    if (existingJobs && customJobs.length > 0) {
+        for (const customPair of customJobs) {
+            existingJobs.add(customPair);
+        }
+        logger.verbose(`📋 Preserved ${customJobs.length} custom job(s) from existing pipeline`);
+    }
+    let yamlContent = stringify(doc, {
+        lineWidth: 0,
+        indent: 2,
+        defaultStringType: 'PLAIN',
+        defaultKeyType: 'PLAIN',
+        minContentWidth: 0
+    });
+    // Insert user section after version job if it exists
+    if (userSection) {
+        const versionOutputsPattern = /^ {2}version:\s*\n(?:.*\n)*? {4}outputs:\s*\n\s*version:.*$/m;
+        const match = yamlContent.match(versionOutputsPattern);
+        if (match) {
+            const insertionIndex = match.index + match[0].length;
+            const userSectionWithMarkers = `# <--START CUSTOM JOBS-->\n\n${userSection}\n\n  # <--END CUSTOM JOBS-->`;
+            yamlContent =
+                yamlContent.slice(0, insertionIndex) +
+                    '\n\n  ' +
+                    userSectionWithMarkers +
+                    '\n' +
+                    yamlContent.slice(insertionIndex);
+            logger.verbose('📋 Inserted user-customized section after version job');
+        }
+    }
+    // Also insert custom jobs that weren't in the user section
+    if (customJobs.length > 0 && !userSection) {
+        const versionOutputsPattern = /^ {2}version:\s*\n(?:.*\n)*? {4}outputs:\s*\n\s*version:.*$/m;
+        const match = yamlContent.match(versionOutputsPattern);
+        if (match) {
+            const insertionIndex = match.index + match[0].length;
+            const customJobsYaml = customJobs
+                .map(pair => {
+                const keyStr = pair.key instanceof Scalar ? pair.key.value : pair.key;
+                const valueYaml = stringify(pair.value, { indent: 2 });
+                return `  ${keyStr}:\n${valueYaml
+                    .split('\n')
+                    .map((line) => (line ? '  ' + line : line))
+                    .join('\n')}`;
+            })
+                .join('\n\n');
+            yamlContent =
+                yamlContent.slice(0, insertionIndex) +
+                    '\n\n  # <--START CUSTOM JOBS-->\n\n' +
+                    customJobsYaml +
+                    '\n\n  # <--END CUSTOM JOBS-->\n' +
+                    yamlContent.slice(insertionIndex);
         }
     }
-    const status = userJobs.size > 0 ? 'merged' : 'updated';
-    const yamlContent = stringify(doc, { lineWidth: 0, minContentWidth: 0 });
+    const status = userSection || customJobs.length > 0 ? 'merged' : 'updated';
     const formattedContent = formatIfConditions(yamlContent);
     return { ...ctx, yamlContent: formattedContent, mergeStatus: status };
 })
     .then(ctx => {
     const outputPath = ctx.outputPipelinePath || '.github/workflows/pipeline.yml';
-    const status = ctx.mergeStatus === 'merged' ? '🔄 Merged with existing' : ctx.mergeStatus === 'updated' ? '🔄 Updated existing' : '📝 Created new';
+    const status = ctx.mergeStatus === 'merged'
+        ? '🔄 Merged with existing'
+        : ctx.mergeStatus === 'updated'
+            ? '🔄 Updated existing'
+            : ctx.mergeStatus === 'rebuilt'
+                ? '🔄 Rebuilt from scratch'
+                : '📝 Created new';
     logger.verbose(`${status} ${outputPath}`);
     return ctx;
 })