@at-blacknight/semantic-release-ci-output 1.0.0

package/.eslintrc.yml

@@ -0,0 +1 @@
+extends: standard

package/.github/workflows/ci.yml

@@ -0,0 +1,58 @@
+name: CI
+
+on:
+  push:
+    branches: [main, alpha, beta]
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [20, 22, 24]
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - run: npm install
+
+      - run: npm run lint
+
+      - run: npm test
+
+  release:
+    needs: test
+    if: github.event_name == 'push'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      issues: write
+      pull-requests: write
+      id-token: write
+      packages: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+          registry-url: 'https://registry.npmjs.org'
+
+      - run: npm install
+
+      - run: npx semantic-release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+

package/.github/workflows/publish.yml

@@ -0,0 +1,28 @@
+name: Publish to GitHub Packages
+
+on:
+  release:
+    types: [created]
+
+permissions:
+  contents: read
+  packages: write
+
+jobs:
+  publish-github:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+          registry-url: 'https://npm.pkg.github.com'
+          scope: '@at-blacknight-projects'
+
+      - run: npm install
+
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_CONFIG_REGISTRY: https://npm.pkg.github.com

package/.releaserc

@@ -0,0 +1,16 @@
+branches:
+  - main
+  - name: alpha
+    prerelease: true
+  - name: beta
+    prerelease: true
+dryRun: false
+ci: true
+plugins:
+  - "@semantic-release/commit-analyzer"
+  - "@semantic-release/release-notes-generator"
+  - "@semantic-release/changelog"
+  - "@semantic-release/npm"
+  - "@semantic-release/github"
+  - - "@semantic-release/git"
+    - message: "chore(release): ${nextRelease.version} ***NO_CI***\n\n${nextRelease.notes}"

package/README.md

@@ -0,0 +1,114 @@
+# @at-blacknight/semantic-release-ci-output
+
+[semantic-release](https://github.com/semantic-release/semantic-release) plugin that outputs release information to CI platforms. Auto-detects the CI environment and writes variables using the native mechanism for each platform.
+
+Works in **dry-run mode** — unlike `@semantic-release/changelog`, the changelog file is written during `generateNotes` which executes in dry-run.
+
+## Supported Platforms
+
+| Platform | Output Mechanism |
+|----------|-----------------|
+| GitHub Actions | Writes to `$GITHUB_OUTPUT` file |
+| Azure DevOps | `##vso[task.setvariable]` commands |
+| GitLab CI/CD | Writes to dotenv file |
+| Other/Local | Logs `key=value` to stdout |
+
+Platform detection is powered by [env-ci](https://github.com/semantic-release/env-ci).
+
+## Install
+
+```bash
+npm install --save-dev @at-blacknight/semantic-release-ci-output
+```
+
+## Usage
+
+Add the plugin to your `plugins` list in your semantic-release configuration. It replaces both `@semantic-release/changelog` and `@semantic-release/exec` for CI variable output.
+
+```yaml
+# .releaserc.yaml
+plugins:
+  - "@semantic-release/commit-analyzer"
+  - "@semantic-release/release-notes-generator"
+  - "@at-blacknight/semantic-release-ci-output"
+```
+
+### With options
+
+```yaml
+plugins:
+  - "@semantic-release/commit-analyzer"
+  - "@semantic-release/release-notes-generator"
+  - - "@at-blacknight/semantic-release-ci-output"
+    - writeNotesFile: true
+      notesFilePath: "CHANGELOG-NEW.md"
+      notesFileBehaviour: "overwrite"
+      setWouldRelease: true
+      setLastReleaseVariables: false
+      isOutput: true
+```
+
+## Output Variables
+
+The following variables are set on the CI platform:
+
+### Always set (analyzeCommits)
+
+| Variable | Description |
+|----------|-------------|
+| `would_release` | `false` initially, set to `true` if a release is determined |
+
+### Set when a release is determined (verifyRelease)
+
+| Variable | Description |
+|----------|-------------|
+| `would_release` | `true` |
+| `version` | The next release version (e.g. `1.2.3`) |
+| `release_type` | The release type (`major`, `minor`, `patch`, `prerelease`) |
+| `release_channel` | The release channel (e.g. `uat`, `develop`, or empty for default) |
+| `git_tag` | The git tag for the release (e.g. `v1.2.3`) |
+| `git_head` | The git commit SHA |
+
+### Last release variables (opt-in)
+
+When `setLastReleaseVariables: true`:
+
+| Variable | Description |
+|----------|-------------|
+| `last_release_version` | Previous release version |
+| `last_release_git_head` | Previous release commit SHA |
+| `last_release_git_tag` | Previous release git tag |
+| `last_release_channel` | Previous release channel |
+
+## Changelog File
+
+By default, the plugin writes the release notes to `CHANGELOG-NEW.md` in the working directory. This happens during `generateNotes` which runs even in `--dry-run` mode.
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `writeNotesFile` | `true` | Write release notes to a file |
+| `notesFilePath` | `CHANGELOG-NEW.md` | Path to the changelog file |
+| `notesFileBehaviour` | `overwrite` | `overwrite`, `prepend`, or `append` |
+
+## Configuration Options
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `setWouldRelease` | `true` | Set the `would_release` variable |
+| `setLastReleaseVariables` | `false` | Set variables for the last release |
+| `isOutput` | `true` | Mark variables as output variables (ADO: `isOutput=true`) |
+| `writeNotesFile` | `true` | Write changelog file |
+| `notesFilePath` | `CHANGELOG-NEW.md` | Changelog file path |
+| `notesFileBehaviour` | `overwrite` | How to handle existing changelog file |
+
+## Lifecycle Hooks
+
+| Hook | Purpose |
+|------|---------|
+| `analyzeCommits` | Sets `would_release=false` and last release variables |
+| `verifyRelease` | Sets `would_release=true` and all release variables |
+| `generateNotes` | Writes the changelog file |
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,9 @@
+const analyzeCommits = require('./lib/analyzeCommits')
+const verifyRelease = require('./lib/verifyRelease')
+const generateNotes = require('./lib/generateNotes')
+
+module.exports = {
+  analyzeCommits,
+  verifyRelease,
+  generateNotes
+}

package/lib/analyzeCommits.js

@@ -0,0 +1,36 @@
+const { getPlatform } = require('./platform')
+
+/**
+ * analyzeCommits hook — runs early in the lifecycle.
+ * Sets last release information and initialises would_release to false.
+ */
+module.exports = async (pluginConfig, context) => {
+  const { lastRelease, logger } = context
+  const { name, adapter } = getPlatform()
+  const isOutput = pluginConfig.isOutput !== false
+
+  logger.log(`Detected CI platform: ${name}`)
+
+  const opts = { logger, isOutput }
+
+  // Set would_release=false initially (overridden in verifyRelease if a release is determined)
+  if (pluginConfig.setWouldRelease !== false) {
+    adapter.setVariable('would_release', 'false', opts)
+  }
+
+  // Set last release variables if available
+  if (pluginConfig.setLastReleaseVariables && lastRelease) {
+    if (lastRelease.version) {
+      adapter.setVariable('last_release_version', lastRelease.version, opts)
+    }
+    if (lastRelease.gitHead) {
+      adapter.setVariable('last_release_git_head', lastRelease.gitHead, opts)
+    }
+    if (lastRelease.gitTag) {
+      adapter.setVariable('last_release_git_tag', lastRelease.gitTag, opts)
+    }
+    if (lastRelease.channel) {
+      adapter.setVariable('last_release_channel', lastRelease.channel, opts)
+    }
+  }
+}

package/lib/generateNotes.js

@@ -0,0 +1,46 @@
+const fs = require('fs')
+const path = require('path')
+
+/**
+ * generateNotes hook — runs after release notes are generated.
+ * Writes the changelog to a file (works in dry-run mode, unlike @semantic-release/changelog).
+ */
+module.exports = async (pluginConfig, context) => {
+  const { nextRelease, logger } = context
+  const writeNotesFile = pluginConfig.writeNotesFile !== false
+  const notesFilePath = pluginConfig.notesFilePath || 'CHANGELOG-NEW.md'
+  const notesFileBehaviour = pluginConfig.notesFileBehaviour || 'overwrite'
+
+  if (!writeNotesFile) {
+    return nextRelease.notes
+  }
+
+  if (!nextRelease.notes) {
+    logger.log('No release notes available, skipping file write')
+    return nextRelease.notes
+  }
+
+  try {
+    const absolutePath = path.resolve(notesFilePath)
+    let finalContent = nextRelease.notes
+
+    if (fs.existsSync(absolutePath) && notesFileBehaviour !== 'overwrite') {
+      const existingContent = fs.readFileSync(absolutePath, 'utf8')
+
+      if (notesFileBehaviour === 'prepend') {
+        finalContent = nextRelease.notes + '\n\n' + existingContent
+      } else if (notesFileBehaviour === 'append') {
+        finalContent = existingContent + '\n\n' + nextRelease.notes
+      }
+    }
+
+    fs.writeFileSync(absolutePath, finalContent, 'utf8')
+    logger.log(`Release notes written to ${notesFilePath} (${finalContent.length} bytes)`)
+  } catch (error) {
+    logger.error(`Failed to write release notes: ${error.message}`)
+    throw error
+  }
+
+  // Return notes unchanged so other plugins can use them
+  return nextRelease.notes
+}

package/lib/platform.js

@@ -0,0 +1,67 @@
+const fs = require('fs')
+
+/**
+ * Platform adapters for writing CI output variables.
+ * Each adapter knows how to set a variable in its CI system.
+ */
+
+const platforms = {
+  github: {
+    setVariable (name, value, { logger }) {
+      const outputFile = process.env.GITHUB_OUTPUT
+      if (!outputFile) {
+        logger.log(`GITHUB_OUTPUT not set, skipping variable ${name}`)
+        return
+      }
+      // Use delimiter for multiline values to avoid injection
+      const delimiter = `ghadelimiter_${Date.now()}`
+      fs.appendFileSync(outputFile, `${name}<<${delimiter}\n${value}\n${delimiter}\n`)
+    }
+  },
+
+  azurePipelines: {
+    setVariable (name, value, { isOutput }) {
+      const outputFlag = isOutput ? 'isOutput=true;' : ''
+      console.log(`##vso[task.setvariable variable=${name};${outputFlag}]${value}`)
+    }
+  },
+
+  gitlab: {
+    setVariable (name, value, { logger }) {
+      const dotenvFile = process.env.DOTENV_FILE || `${process.env.CI_PROJECT_DIR}/.env`
+      try {
+        fs.appendFileSync(dotenvFile, `${name}=${value}\n`)
+      } catch (err) {
+        // Fall back to stdout
+        logger.log('Could not write to dotenv file, falling back to stdout')
+        console.log(`${name}=${value}`)
+      }
+    }
+  }
+}
+
+/**
+ * Detect the current CI platform and return the appropriate adapter.
+ * Falls back to a console logger for unknown/local platforms.
+ */
+function getPlatform () {
+  const envCiModule = require('env-ci')
+  const envCi = envCiModule.default || envCiModule
+  const { service } = envCi()
+
+  if (platforms[service]) {
+    return { name: service, adapter: platforms[service] }
+  }
+
+  // Fallback: log to stdout
+  return {
+    name: service || 'unknown',
+    adapter: {
+      setVariable (name, value) {
+        console.log(`${name}=${value}`)
+      }
+    }
+  }
+}
+
+module.exports = { getPlatform, platforms }

package/lib/verifyRelease.js

@@ -0,0 +1,37 @@
+const { getPlatform } = require('./platform')
+
+/**
+ * verifyRelease hook — runs when a release has been determined.
+ * Sets would_release=true and outputs all release variables.
+ */
+module.exports = async (pluginConfig, context) => {
+  const { nextRelease, logger } = context
+  const { adapter } = getPlatform()
+  const isOutput = pluginConfig.isOutput !== false
+
+  const opts = { logger, isOutput }
+
+  logger.log(`Release determined: ${nextRelease.version} (${nextRelease.type})`)
+
+  // Override would_release to true
+  if (pluginConfig.setWouldRelease !== false) {
+    adapter.setVariable('would_release', 'true', opts)
+  }
+
+  // Set release object variables
+  if (nextRelease.version) {
+    adapter.setVariable('version', nextRelease.version, opts)
+  }
+  if (nextRelease.type) {
+    adapter.setVariable('release_type', nextRelease.type, opts)
+  }
+  if (nextRelease.channel) {
+    adapter.setVariable('release_channel', nextRelease.channel, opts)
+  }
+  if (nextRelease.gitTag) {
+    adapter.setVariable('git_tag', nextRelease.gitTag, opts)
+  }
+  if (nextRelease.gitHead) {
+    adapter.setVariable('git_head', nextRelease.gitHead, opts)
+  }
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@at-blacknight/semantic-release-ci-output",
+  "version": "1.0.0",
+  "description": "Semantic release plugin that outputs release information to CI platforms (GitHub Actions, Azure DevOps, GitLab CI, and more).",
+  "main": "index.js",
+  "scripts": {
+    "test": "node --test --test-concurrency=1",
+    "lint": "eslint lib index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/at-blacknight-projects/semantic-release-ci-output.git"
+  },
+  "author": "Adam Butler",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/at-blacknight-projects/semantic-release-ci-output/issues"
+  },
+  "homepage": "https://github.com/at-blacknight-projects/semantic-release-ci-output#readme",
+  "keywords": [
+    "semantic-release",
+    "github-actions",
+    "azure-devops",
+    "gitlab-ci",
+    "ci",
+    "pipeline",
+    "output",
+    "variables"
+  ],
+  "dependencies": {
+    "env-ci": "^11.0.0"
+  },
+  "peerDependencies": {
+    "semantic-release": ">=20.0.0"
+  },
+  "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^12.0.6",
+    "eslint": "^8.57.1",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-n": "^16.6.2",
+    "eslint-plugin-promise": "^6.6.0",
+    "semantic-release": "^25.0.3"
+  }
+}

package/test/analyzeCommits.test.js

@@ -0,0 +1,94 @@
+const { describe, it, beforeEach, afterEach } = require('node:test')
+const assert = require('node:assert/strict')
+const fs = require('fs')
+const path = require('path')
+
+describe('analyzeCommits', () => {
+  const tmpFile = path.join(__dirname, 'test-github-output.txt')
+  let analyzeCommits
+
+  beforeEach(() => {
+    fs.writeFileSync(tmpFile, '')
+    process.env.GITHUB_OUTPUT = tmpFile
+    process.env.GITHUB_ACTIONS = 'true'
+    process.env.CI = 'true'
+
+    // Clear require cache so env-ci re-detects platform
+    Object.keys(require.cache).forEach(key => {
+      if (key.includes('env-ci') || key.includes('platform') || key.includes('analyzeCommits')) {
+        delete require.cache[key]
+      }
+    })
+    analyzeCommits = require('../lib/analyzeCommits')
+  })
+
+  afterEach(() => {
+    if (fs.existsSync(tmpFile)) fs.unlinkSync(tmpFile)
+    delete process.env.GITHUB_OUTPUT
+    delete process.env.GITHUB_ACTIONS
+    delete process.env.CI
+  })
+
+  function readOutput () {
+    return fs.readFileSync(tmpFile, 'utf8')
+  }
+
+  it('sets would_release to false', async () => {
+    await analyzeCommits({}, { lastRelease: {}, logger: { log () {} } })
+    const output = readOutput()
+    assert.ok(output.includes('would_release'))
+    assert.ok(output.includes('false'))
+  })
+
+  it('respects setWouldRelease: false', async () => {
+    await analyzeCommits(
+      { setWouldRelease: false },
+      { lastRelease: {}, logger: { log () {} } }
+    )
+    const output = readOutput()
+    assert.ok(!output.includes('would_release'))
+  })
+
+  it('sets last release variables when enabled', async () => {
+    const lastRelease = {
+      version: '2.0.0',
+      gitHead: 'abc123',
+      gitTag: 'v2.0.0',
+      channel: 'main'
+    }
+
+    await analyzeCommits(
+      { setLastReleaseVariables: true },
+      { lastRelease, logger: { log () {} } }
+    )
+
+    const output = readOutput()
+    assert.ok(output.includes('last_release_version'))
+    assert.ok(output.includes('2.0.0'))
+    assert.ok(output.includes('last_release_git_head'))
+    assert.ok(output.includes('abc123'))
+    assert.ok(output.includes('last_release_git_tag'))
+    assert.ok(output.includes('v2.0.0'))
+    assert.ok(output.includes('last_release_channel'))
+    assert.ok(output.includes('main'))
+  })
+
+  it('does not set last release variables by default', async () => {
+    await analyzeCommits(
+      {},
+      { lastRelease: { version: '1.0.0' }, logger: { log () {} } }
+    )
+    const output = readOutput()
+    assert.ok(!output.includes('last_release_version'))
+  })
+
+  it('handles missing lastRelease properties gracefully', async () => {
+    await analyzeCommits(
+      { setLastReleaseVariables: true },
+      { lastRelease: { version: '1.0.0' }, logger: { log () {} } }
+    )
+    const output = readOutput()
+    assert.ok(output.includes('last_release_version'))
+    assert.ok(!output.includes('last_release_git_head'))
+  })
+})

package/test/generateNotes.test.js

@@ -0,0 +1,121 @@
+const { describe, it, beforeEach, afterEach } = require('node:test')
+const assert = require('node:assert/strict')
+const fs = require('fs')
+const path = require('path')
+
+const generateNotes = require('../lib/generateNotes')
+
+describe('generateNotes', () => {
+  const tmpDir = path.join(__dirname, 'tmp')
+  const testFile = path.join(tmpDir, 'CHANGELOG-NEW.md')
+  const logger = { log () {}, error () {} }
+
+  beforeEach(() => {
+    if (!fs.existsSync(tmpDir)) fs.mkdirSync(tmpDir, { recursive: true })
+  })
+
+  afterEach(() => {
+    if (fs.existsSync(tmpDir)) fs.rmSync(tmpDir, { recursive: true })
+  })
+
+  it('writes release notes to file', async () => {
+    const notes = '## 1.0.0\n\n* Initial release'
+    const result = await generateNotes(
+      { notesFilePath: testFile },
+      { nextRelease: { notes }, logger }
+    )
+    assert.equal(fs.readFileSync(testFile, 'utf8'), notes)
+    assert.equal(result, notes)
+  })
+
+  it('returns notes unchanged', async () => {
+    const notes = '## 2.0.0\n\n* Breaking change'
+    const result = await generateNotes(
+      { notesFilePath: testFile },
+      { nextRelease: { notes }, logger }
+    )
+    assert.equal(result, notes)
+  })
+
+  it('skips file write when writeNotesFile is false', async () => {
+    const notes = '## 1.0.0\n\n* Some notes'
+    await generateNotes(
+      { writeNotesFile: false, notesFilePath: testFile },
+      { nextRelease: { notes }, logger }
+    )
+    assert.ok(!fs.existsSync(testFile))
+  })
+
+  it('skips file write when notes are empty', async () => {
+    await generateNotes(
+      { notesFilePath: testFile },
+      { nextRelease: { notes: '' }, logger }
+    )
+    assert.ok(!fs.existsSync(testFile))
+  })
+
+  it('skips file write when notes are undefined', async () => {
+    await generateNotes(
+      { notesFilePath: testFile },
+      { nextRelease: {}, logger }
+    )
+    assert.ok(!fs.existsSync(testFile))
+  })
+
+  it('overwrites existing file by default', async () => {
+    fs.writeFileSync(testFile, 'old content')
+    const notes = '## 2.0.0\n\n* New release'
+    await generateNotes(
+      { notesFilePath: testFile },
+      { nextRelease: { notes }, logger }
+    )
+    assert.equal(fs.readFileSync(testFile, 'utf8'), notes)
+  })
+
+  it('prepends to existing file', async () => {
+    fs.writeFileSync(testFile, '## 1.0.0\n\n* Old release')
+    const notes = '## 2.0.0\n\n* New release'
+    await generateNotes(
+      { notesFilePath: testFile, notesFileBehaviour: 'prepend' },
+      { nextRelease: { notes }, logger }
+    )
+    const content = fs.readFileSync(testFile, 'utf8')
+    assert.ok(content.startsWith('## 2.0.0'))
+    assert.ok(content.includes('## 1.0.0'))
+    assert.ok(content.indexOf('2.0.0') < content.indexOf('1.0.0'))
+  })
+
+  it('appends to existing file', async () => {
+    fs.writeFileSync(testFile, '## 1.0.0\n\n* Old release')
+    const notes = '## 2.0.0\n\n* New release'
+    await generateNotes(
+      { notesFilePath: testFile, notesFileBehaviour: 'append' },
+      { nextRelease: { notes }, logger }
+    )
+    const content = fs.readFileSync(testFile, 'utf8')
+    assert.ok(content.startsWith('## 1.0.0'))
+    assert.ok(content.includes('## 2.0.0'))
+    assert.ok(content.indexOf('1.0.0') < content.indexOf('2.0.0'))
+  })
+
+  it('creates file if it does not exist for prepend mode', async () => {
+    const notes = '## 1.0.0\n\n* First release'
+    await generateNotes(
+      { notesFilePath: testFile, notesFileBehaviour: 'prepend' },
+      { nextRelease: { notes }, logger }
+    )
+    assert.equal(fs.readFileSync(testFile, 'utf8'), notes)
+  })
+
+  it('uses default path CHANGELOG-NEW.md', async () => {
+    const defaultFile = path.resolve('CHANGELOG-NEW.md')
+    const notes = '## 1.0.0\n\n* Test'
+    try {
+      await generateNotes({}, { nextRelease: { notes }, logger })
+      assert.ok(fs.existsSync(defaultFile))
+      assert.equal(fs.readFileSync(defaultFile, 'utf8'), notes)
+    } finally {
+      if (fs.existsSync(defaultFile)) fs.unlinkSync(defaultFile)
+    }
+  })
+})

package/test/platform.test.js

@@ -0,0 +1,119 @@
+const { describe, it, beforeEach, afterEach } = require('node:test')
+const assert = require('node:assert/strict')
+const fs = require('fs')
+const path = require('path')
+const { platforms } = require('../lib/platform')
+
+describe('platform adapters', () => {
+  describe('github', () => {
+    const tmpFile = path.join(__dirname, 'test-github-output.txt')
+    const logger = { log () {} }
+
+    beforeEach(() => {
+      fs.writeFileSync(tmpFile, '')
+      process.env.GITHUB_OUTPUT = tmpFile
+    })
+
+    afterEach(() => {
+      if (fs.existsSync(tmpFile)) fs.unlinkSync(tmpFile)
+      delete process.env.GITHUB_OUTPUT
+    })
+
+    it('writes variable to GITHUB_OUTPUT file', () => {
+      platforms.github.setVariable('version', '1.2.3', { logger, isOutput: true })
+      const content = fs.readFileSync(tmpFile, 'utf8')
+      assert.match(content, /version<<ghadelimiter_\d+\n1\.2\.3\nghadelimiter_\d+\n/)
+    })
+
+    it('handles multiline values with delimiter', () => {
+      platforms.github.setVariable('notes', 'Line 1\nLine 2\nLine 3', { logger, isOutput: true })
+      const content = fs.readFileSync(tmpFile, 'utf8')
+      assert.ok(content.includes('Line 1\nLine 2\nLine 3'))
+      // Delimiter should wrap the value
+      const lines = content.split('\n')
+      assert.match(lines[0], /notes<<ghadelimiter_\d+/)
+      assert.match(lines[lines.length - 2], /ghadelimiter_\d+/)
+    })
+
+    it('skips when GITHUB_OUTPUT is not set', () => {
+      delete process.env.GITHUB_OUTPUT
+      const logs = []
+      const testLogger = { log: (msg) => logs.push(msg) }
+      platforms.github.setVariable('version', '1.2.3', { logger: testLogger, isOutput: true })
+      assert.ok(logs.some(l => l.includes('GITHUB_OUTPUT not set')))
+    })
+
+    it('appends multiple variables to the same file', () => {
+      platforms.github.setVariable('version', '1.0.0', { logger, isOutput: true })
+      platforms.github.setVariable('release_type', 'major', { logger, isOutput: true })
+      const content = fs.readFileSync(tmpFile, 'utf8')
+      assert.ok(content.includes('version'))
+      assert.ok(content.includes('release_type'))
+    })
+  })
+
+  describe('azurePipelines', () => {
+    it('outputs vso command with isOutput flag', () => {
+      const logs = []
+      const origLog = console.log
+      console.log = (msg) => logs.push(msg)
+      try {
+        platforms.azurePipelines.setVariable('version', '1.2.3', { isOutput: true })
+        assert.equal(logs[0], '##vso[task.setvariable variable=version;isOutput=true;]1.2.3')
+      } finally {
+        console.log = origLog
+      }
+    })
+
+    it('outputs vso command without isOutput flag', () => {
+      const logs = []
+      const origLog = console.log
+      console.log = (msg) => logs.push(msg)
+      try {
+        platforms.azurePipelines.setVariable('version', '1.2.3', { isOutput: false })
+        assert.equal(logs[0], '##vso[task.setvariable variable=version;]1.2.3')
+      } finally {
+        console.log = origLog
+      }
+    })
+  })
+
+  describe('gitlab', () => {
+    const tmpFile = path.join(__dirname, 'test-dotenv.txt')
+    const logger = { log () {} }
+
+    beforeEach(() => {
+      process.env.DOTENV_FILE = tmpFile
+    })
+
+    afterEach(() => {
+      if (fs.existsSync(tmpFile)) fs.unlinkSync(tmpFile)
+      delete process.env.DOTENV_FILE
+      delete process.env.CI_PROJECT_DIR
+    })
+
+    it('writes variable to dotenv file', () => {
+      fs.writeFileSync(tmpFile, '')
+      platforms.gitlab.setVariable('version', '1.2.3', { logger, isOutput: true })
+      const content = fs.readFileSync(tmpFile, 'utf8')
+      assert.equal(content, 'version=1.2.3\n')
+    })
+
+    it('falls back to stdout when dotenv file is not writable', () => {
+      delete process.env.DOTENV_FILE
+      process.env.CI_PROJECT_DIR = '/nonexistent/path'
+      const logs = []
+      const origLog = console.log
+      console.log = (msg) => logs.push(msg)
+      const loggerLogs = []
+      const testLogger = { log: (msg) => loggerLogs.push(msg) }
+      try {
+        platforms.gitlab.setVariable('version', '1.2.3', { logger: testLogger, isOutput: true })
+        assert.ok(loggerLogs.some(l => l.includes('falling back to stdout')))
+        assert.ok(logs.some(l => l === 'version=1.2.3'))
+      } finally {
+        console.log = origLog
+      }
+    })
+  })
+})

package/test/verifyRelease.test.js

@@ -0,0 +1,84 @@
+const { describe, it, beforeEach, afterEach } = require('node:test')
+const assert = require('node:assert/strict')
+const fs = require('fs')
+const path = require('path')
+
+describe('verifyRelease', () => {
+  const tmpFile = path.join(__dirname, 'test-github-output.txt')
+  let verifyRelease
+
+  beforeEach(() => {
+    fs.writeFileSync(tmpFile, '')
+    process.env.GITHUB_OUTPUT = tmpFile
+    process.env.GITHUB_ACTIONS = 'true'
+    process.env.CI = 'true'
+
+    Object.keys(require.cache).forEach(key => {
+      if (key.includes('env-ci') || key.includes('platform') || key.includes('verifyRelease')) {
+        delete require.cache[key]
+      }
+    })
+    verifyRelease = require('../lib/verifyRelease')
+  })
+
+  afterEach(() => {
+    if (fs.existsSync(tmpFile)) fs.unlinkSync(tmpFile)
+    delete process.env.GITHUB_OUTPUT
+    delete process.env.GITHUB_ACTIONS
+    delete process.env.CI
+  })
+
+  function readOutput () {
+    return fs.readFileSync(tmpFile, 'utf8')
+  }
+
+  it('sets would_release to true', async () => {
+    const nextRelease = { version: '1.0.0', type: 'major', gitTag: 'v1.0.0', gitHead: 'abc123' }
+    await verifyRelease({}, { nextRelease, logger: { log () {} } })
+    const output = readOutput()
+    assert.ok(output.includes('would_release'))
+    assert.ok(output.includes('true'))
+  })
+
+  it('sets all release variables', async () => {
+    const nextRelease = {
+      version: '2.1.0',
+      type: 'minor',
+      channel: 'beta',
+      gitTag: 'v2.1.0-beta.1',
+      gitHead: 'def456'
+    }
+    await verifyRelease({}, { nextRelease, logger: { log () {} } })
+    const output = readOutput()
+    assert.ok(output.includes('version'))
+    assert.ok(output.includes('2.1.0'))
+    assert.ok(output.includes('release_type'))
+    assert.ok(output.includes('minor'))
+    assert.ok(output.includes('release_channel'))
+    assert.ok(output.includes('beta'))
+    assert.ok(output.includes('git_tag'))
+    assert.ok(output.includes('v2.1.0-beta.1'))
+    assert.ok(output.includes('git_head'))
+    assert.ok(output.includes('def456'))
+  })
+
+  it('respects setWouldRelease: false', async () => {
+    const nextRelease = { version: '1.0.0', type: 'major', gitTag: 'v1.0.0', gitHead: 'abc123' }
+    await verifyRelease({ setWouldRelease: false }, { nextRelease, logger: { log () {} } })
+    const output = readOutput()
+    assert.ok(!output.includes('would_release'))
+    // Other variables should still be set
+    assert.ok(output.includes('version'))
+  })
+
+  it('handles missing optional nextRelease properties', async () => {
+    const nextRelease = { version: '1.0.0', type: 'patch' }
+    await verifyRelease({}, { nextRelease, logger: { log () {} } })
+    const output = readOutput()
+    assert.ok(output.includes('version'))
+    assert.ok(output.includes('release_type'))
+    assert.ok(!output.includes('release_channel'))
+    assert.ok(!output.includes('git_tag'))
+    assert.ok(!output.includes('git_head'))
+  })
+})