fg-devkit 1.9.1 → 1.12.0

package/scripts/release.sh

@@ -1,12 +1,14 @@
 #!/usr/bin/env bash
 #
 # Interactive or scripted release for this package: bumps version with pnpm, pushes commits/tags,
-# and creates a GitHub Release with generated notes (requires gh CLI, authenticated).
+# and creates a GitHub Release (requires gh CLI, authenticated).
+#
+# Repos with cliff.toml / CHANGELOG files run git-cliff generation and an interactive
+# verification step before commit. Others use gh --generate-notes.
 #
 # Usage:
-#   ./scripts/release.sh [patch|minor|major]              # stable release (default mode)
-#   ./scripts/release.sh [patch|minor|major] candidate  # prerelease tag X.Y.Z-rc.N
-#   ./scripts/release.sh candidate [patch|minor|major]
+#   ./scripts/release.sh [patch|minor|major] [--skip-release-notes]
+#   ./scripts/release.sh [patch|minor|major] candidate [--skip-release-notes]
 #
 # Candidate tags follow SemVer prerelease format: <version>-rc.<number> (e.g. 2.8.0-rc.1).
 
@@ -14,14 +16,17 @@ set -euo pipefail
 
 bump_type=""
 release_mode="release"
+skip_release_notes="${FG_DEVKIT_SKIP_RELEASE_NOTES:-0}"
+use_release_notes=0
 
 for arg in "$@"; do
   case "$arg" in
     patch | minor | major) bump_type="$arg" ;;
     release | candidate) release_mode="$arg" ;;
+    --skip-release-notes) skip_release_notes=1 ;;
     *)
       echo "Unknown argument: $arg"
-      echo "Usage: ./scripts/release.sh [patch|minor|major] [release|candidate]"
+      echo "Usage: ./scripts/release.sh [patch|minor|major] [release|candidate] [--skip-release-notes]"
       exit 1
       ;;
   esac
@@ -80,8 +85,142 @@ sync_fg_devkit_package_files() {
   fi
 }
 
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+has_release_notes_config() {
+  [[ -f cliff.toml || -f cliff.user.toml || -f CHANGELOG.md || -f CHANGELOG.user.md ]]
+}
+
+generate_release_notes() {
+  local tag="$1"
+  if [[ "$skip_release_notes" == "1" ]]; then
+    return 0
+  fi
+  if ! has_release_notes_config; then
+    return 0
+  fi
+
+  local args=()
+  if [[ -n "$tag" ]]; then
+    args+=("--tag=${tag}")
+  fi
+
+  node "${script_dir}/generate-release-notes.mjs" "${args[@]}"
+}
+
+discard_release_notes_changes() {
+  for file in CHANGELOG.md CHANGELOG.user.md CHANGELOG.user.draft.md; do
+    if [[ ! -f "$file" ]]; then
+      continue
+    fi
+
+    if git ls-files --error-unmatch "$file" >/dev/null 2>&1; then
+      git checkout -- "$file"
+    else
+      rm -f "$file"
+    fi
+  done
+}
+
+verify_release_notes() {
+  if [[ "$skip_release_notes" == "1" ]]; then
+    return 0
+  fi
+  if ! has_release_notes_config; then
+    return 0
+  fi
+
+  set +e
+  FG_DEVKIT_RELEASE_TAG="${new_tag:-}" node "${script_dir}/verify-release-notes.mjs"
+  local code=$?
+  set -e
+
+  if [[ "$code" -eq 2 ]]; then
+    skip_release_notes=1
+    use_release_notes=0
+    discard_release_notes_changes
+    echo "Release notes skipped. Using GitHub-generated notes."
+    return 0
+  fi
+
+  return "$code"
+}
+
+stage_release_notes() {
+  if [[ "$use_release_notes" != "1" ]]; then
+    return 0
+  fi
+
+  for file in CHANGELOG.md CHANGELOG.user.md CHANGELOG.user.draft.md; do
+    if [[ -f "$file" ]]; then
+      git add "$file"
+    fi
+  done
+}
+
+run_release_notes_phase() {
+  local tag="$1"
+
+  if [[ "$skip_release_notes" == "1" ]]; then
+    echo "Skipping release notes."
+    return 0
+  fi
+
+  if ! has_release_notes_config; then
+    return 0
+  fi
+
+  use_release_notes=1
+  generate_release_notes "$tag"
+  verify_release_notes
+  stage_release_notes
+}
+
+create_github_release() {
+  local tag="$1"
+  local prerelease_flag="${2:-}"
+
+  if [[ "$use_release_notes" == "1" ]] && [[ -f CHANGELOG.md ]]; then
+    if [[ -n "$prerelease_flag" ]]; then
+      gh release create "$tag" \
+        --prerelease \
+        --title "$tag" \
+        --notes-file CHANGELOG.md
+    else
+      gh release create "$tag" \
+        --latest \
+        --title "$tag" \
+        --notes-file CHANGELOG.md
+    fi
+    return 0
+  fi
+
+  if [[ -n "$previous_tag" ]]; then
+    if [[ -n "$prerelease_flag" ]]; then
+      gh release create "$tag" \
+        --prerelease \
+        --generate-notes \
+        --notes-start-tag "$previous_tag"
+    else
+      gh release create "$tag" \
+        --latest \
+        --generate-notes \
+        --notes-start-tag "$previous_tag"
+    fi
+  else
+    if [[ -n "$prerelease_flag" ]]; then
+      gh release create "$tag" \
+        --prerelease \
+        --generate-notes
+    else
+      gh release create "$tag" \
+        --latest \
+        --generate-notes
+    fi
+  fi
+}
+
 if [[ "$release_mode" == "candidate" ]]; then
-  script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
   new_version="$(node "${script_dir}/resolve-candidate-version.mjs" "$bump_type")"
 
   node -e "
@@ -94,22 +233,16 @@ fs.writeFileSync('package.json', JSON.stringify(pkg, null, 2) + '\n');
   sync_fg_devkit_package_files
 
   new_tag="v${new_version}"
+
+  run_release_notes_phase "$new_tag"
+
   git commit -m "${new_tag}"
   git tag "${new_tag}"
 
   git push
   git push --tags
 
-  if [[ -n "$previous_tag" ]]; then
-    gh release create "$new_tag" \
-      --prerelease \
-      --generate-notes \
-      --notes-start-tag "$previous_tag"
-  else
-    gh release create "$new_tag" \
-      --prerelease \
-      --generate-notes
-  fi
+  create_github_release "$new_tag" "--prerelease"
 
   echo "Candidate release created: ${new_tag}"
   exit 0
@@ -122,21 +255,14 @@ new_tag="v${new_version}"
 
 sync_fg_devkit_package_files
 
+run_release_notes_phase "$new_tag"
+
 git commit -m "${new_tag}"
 git tag "${new_tag}"
 
 git push
 git push --tags
 
-if [[ -n "$previous_tag" ]]; then
-  gh release create "$new_tag" \
-    --latest \
-    --generate-notes \
-    --notes-start-tag "$previous_tag"
-else
-  gh release create "$new_tag" \
-    --latest \
-    --generate-notes
-fi
+create_github_release "$new_tag"
 
 echo "Release created: ${new_tag}"

package/scripts/sync-consumer-scripts.mjs

@@ -16,6 +16,7 @@ const REQUIRED_SCRIPTS = {
   'lint:ts': 'pnpm exec fgd typecheck',
   lint: 'pnpm exec fgd lint --fix .',
   'lint-check': 'pnpm exec fgd lint .',
+  'generate:release-notes': 'pnpm exec fgd generate-release-notes',
 }
 
 function main() {

package/scripts/sync-dependency-policy.mjs

@@ -4,7 +4,7 @@
  *
  * Only updates keys that already exist in package.json (does not add new dependencies from the policy).
  * Aligns managedDependencies, managedAnywhere (only where the package is already declared), optional
- * policy overrides into pnpm.overrides, and logs each change.
+ * policy overrides into pnpm.overrides, toolchain.packageManager into package.json, and logs each change.
  *
  * Refuses to run if the policy file contains any non-pinned versions.
  *
@@ -16,6 +16,10 @@ import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 
 import { collectPinViolations } from './dependency-policy-pins.mjs'
+import {
+  collectToolchainPolicyViolations,
+  resolveExpectedPackageManager,
+} from './dependency-policy-toolchain.mjs'
 import { resolveDependencyPolicyPath } from './resolve-dependency-policy-path.mjs'
 
 const cwd = process.cwd()
@@ -44,6 +48,7 @@ const policyErrors = [
     collectPinViolations(`managedDependencies.${section}.`, deps),
   ),
   ...collectPinViolations('managedAnywhere.', policy.managedAnywhere ?? {}),
+  ...collectToolchainPolicyViolations(policy),
 ]
 
 if (policyErrors.length > 0) {
@@ -136,6 +141,12 @@ for (const [name, version] of Object.entries(getRelevantPolicyOverrides(policy.o
   }
 }
 
+const expectedPackageManager = resolveExpectedPackageManager(policy, path.resolve(scriptDir, '..'))
+if (expectedPackageManager !== undefined && pkg.packageManager !== expectedPackageManager) {
+  changes.push(`packageManager: ${pkg.packageManager ?? '(missing)'} -> ${expectedPackageManager}`)
+  pkg.packageManager = expectedPackageManager
+}
+
 if (changes.length === 0) {
   console.log('[sync-deps] package.json already matches dependency policy')
   process.exit(0)

package/scripts/sync-release-notes-config.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+/**
+ * Copy default cliff configs into a consumer repo when missing and ensure the
+ * generate-release-notes npm script is present.
+ *
+ * Usage:
+ *   node node_modules/fg-devkit/scripts/sync-release-notes-config.mjs
+ *   pnpm exec fg-devkit sync-release-notes-config
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { fgRoot } from './release-notes-common.mjs'
+
+const REQUIRED_SCRIPT = 'generate:release-notes'
+const REQUIRED_SCRIPT_VALUE = 'pnpm exec fgd generate-release-notes'
+
+const CONFIG_FILES = ['cliff.toml', 'cliff.user.toml']
+
+function copyIfMissing(fileName, cwd) {
+  const target = path.join(cwd, fileName)
+  if (fs.existsSync(target)) {
+    return null
+  }
+
+  const source = path.join(fgRoot, 'configs', fileName)
+  if (!fs.existsSync(source)) {
+    console.error(`[sync-release-notes-config] Missing template: ${source}`)
+    process.exit(1)
+  }
+
+  fs.copyFileSync(source, target)
+  return fileName
+}
+
+function ensureUserChangelog(cwd) {
+  const target = path.join(cwd, 'CHANGELOG.user.md')
+  if (fs.existsSync(target)) {
+    return null
+  }
+
+  fs.writeFileSync(target, '')
+  return 'CHANGELOG.user.md'
+}
+
+function main() {
+  const cwd = process.cwd()
+  const packageJsonPath = path.join(cwd, 'package.json')
+
+  if (!fs.existsSync(packageJsonPath)) {
+    console.error(`[sync-release-notes-config] package.json not found at ${packageJsonPath}`)
+    process.exit(1)
+  }
+
+  const copied = []
+  for (const fileName of CONFIG_FILES) {
+    const result = copyIfMissing(fileName, cwd)
+    if (result) {
+      copied.push(result)
+    }
+  }
+
+  const createdChangelog = ensureUserChangelog(cwd)
+  if (createdChangelog) {
+    copied.push(createdChangelog)
+  }
+
+  let pkg
+  try {
+    pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
+  } catch (err) {
+    console.error(`[sync-release-notes-config] Failed to parse package.json: ${err.message}`)
+    process.exit(1)
+  }
+
+  pkg.scripts = pkg.scripts && typeof pkg.scripts === 'object' ? pkg.scripts : {}
+  let scriptUpdated = false
+  if (pkg.scripts[REQUIRED_SCRIPT] !== REQUIRED_SCRIPT_VALUE) {
+    pkg.scripts[REQUIRED_SCRIPT] = REQUIRED_SCRIPT_VALUE
+    scriptUpdated = true
+  }
+
+  if (scriptUpdated) {
+    fs.writeFileSync(packageJsonPath, `${JSON.stringify(pkg, null, 2)}\n`, 'utf8')
+  }
+
+  if (copied.length === 0 && !scriptUpdated) {
+    console.log('[sync-release-notes-config] Release-notes config already up to date.')
+    return
+  }
+
+  if (copied.length > 0) {
+    console.log('[sync-release-notes-config] Added files:')
+    for (const fileName of copied) {
+      console.log(`  - ${fileName}`)
+    }
+  }
+
+  if (scriptUpdated) {
+    console.log(`[sync-release-notes-config] Updated script: ${REQUIRED_SCRIPT}`)
+  }
+}
+
+main()

package/scripts/sync-scaffold-vue-deps.mjs

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 /**
  * Aligns scaffold/vue/package.json dependency versions with dependency-policy.vue-workspace.json.
- * Also pins scaffold devDependency `fg-devkit` to the fg-devkit package version at publish time.
+ * Also pins scaffold devDependency `fg-devkit` to the fg-devkit package version at publish time,
+ * and syncs toolchain.packageManager into scaffold package.json and Dockerfile.local.
  *
  * Invoked automatically after refresh-dependency-policy-from-repos.mjs writes the policy, and
  * can be run manually: node …/sync-scaffold-vue-deps.mjs [policy-file]
@@ -12,13 +13,27 @@ import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 
 import { resolveDependencyPolicyPath } from './resolve-dependency-policy-path.mjs'
+import {
+  extractPnpmVersion,
+  resolveExpectedPackageManager,
+  syncPolicyToolchainFromFgDevkit,
+} from './dependency-policy-toolchain.mjs'
 
 /**
  * @param {{ fgDevkitRoot: string, policyPath: string }} options
  */
 export function syncScaffoldVueDepsFromPolicy(options) {
   const { fgDevkitRoot, policyPath } = options
-  const policy = JSON.parse(fs.readFileSync(policyPath, 'utf8'))
+  let policy = JSON.parse(fs.readFileSync(policyPath, 'utf8'))
+  const { policy: syncedPolicy, changed: toolchainChanged } = syncPolicyToolchainFromFgDevkit(
+    policy,
+    fgDevkitRoot,
+  )
+  policy = syncedPolicy
+  if (toolchainChanged) {
+    fs.writeFileSync(policyPath, `${JSON.stringify(policy, null, 2)}\n`)
+    console.log('[sync-scaffold-vue-deps] Updated toolchain in', policyPath)
+  }
   const scaffoldPkgPath = path.join(fgDevkitRoot, 'scaffold/vue/package.json')
   if (!fs.existsSync(scaffoldPkgPath)) {
     console.warn('[sync-scaffold-vue-deps] No scaffold package at', scaffoldPkgPath)
@@ -53,6 +68,24 @@ export function syncScaffoldVueDepsFromPolicy(options) {
   applySection('dependencies')
   applySection('devDependencies')
 
+  const expectedPackageManager = resolveExpectedPackageManager(policy, fgDevkitRoot)
+  if (expectedPackageManager !== undefined) {
+    pkg.packageManager = expectedPackageManager
+    const dockerfilePath = path.join(fgDevkitRoot, 'scaffold/vue/Dockerfile.local')
+    const pnpmVersion = extractPnpmVersion(expectedPackageManager)
+    if (pnpmVersion && fs.existsSync(dockerfilePath)) {
+      const dockerfile = fs.readFileSync(dockerfilePath, 'utf8')
+      const updatedDockerfile = dockerfile.replace(
+        /corepack prepare pnpm@[^\s]+ --activate/,
+        `corepack prepare pnpm@${pnpmVersion} --activate`,
+      )
+      if (updatedDockerfile !== dockerfile) {
+        fs.writeFileSync(dockerfilePath, updatedDockerfile)
+        console.log('[sync-scaffold-vue-deps] Updated', dockerfilePath)
+      }
+    }
+  }
+
   fs.writeFileSync(scaffoldPkgPath, `${JSON.stringify(pkg, null, 2)}\n`)
   console.log('[sync-scaffold-vue-deps] Updated', scaffoldPkgPath)
 }

package/scripts/verify-release-notes.mjs

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+/**
+ * Interactive verification step before committing release notes.
+ *
+ * Usage:
+ *   node node_modules/fg-devkit/scripts/verify-release-notes.mjs
+ *   pnpm exec fg-devkit verify-release-notes
+ *
+ * Exit codes: 0 = approved, 1 = aborted/error, 2 = skip release notes
+ */
+
+import { spawnSync } from 'node:child_process'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import confirm from '@inquirer/confirm'
+import select from '@inquirer/select'
+import {
+  hasReleaseNotesConfig,
+  readPreviewFiles,
+  runSyncUserChangelog,
+} from './release-notes-common.mjs'
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url))
+const cwd = process.cwd()
+
+function showPreview() {
+  const previews = readPreviewFiles(cwd)
+
+  if (previews.length === 0) {
+    console.log('[fg-devkit] No changelog files to preview yet.')
+    return
+  }
+
+  for (const { file, content } of previews) {
+    const divider = '─'.repeat(Math.max(8, 50 - file.length))
+    console.log(`\n── ${file} ${divider}`)
+    console.log(content.trimEnd())
+  }
+}
+
+function runGenerateReleaseNotes() {
+  const generateScript = path.join(scriptDir, 'generate-release-notes.mjs')
+  const tagArg = process.env.FG_DEVKIT_RELEASE_TAG
+  const args = [generateScript]
+  if (tagArg) {
+    args.push(`--tag=${tagArg}`)
+  }
+
+  const r = spawnSync(process.execPath, args, {
+    stdio: 'inherit',
+    cwd,
+    env: process.env,
+  })
+
+  return r.status ?? 1
+}
+
+function openEditor(fileName) {
+  const editor = process.env.EDITOR ?? process.env.VISUAL ?? 'nano'
+  const filePath = path.join(cwd, fileName)
+  const r = spawnSync(editor, [filePath], {
+    stdio: 'inherit',
+    cwd,
+    env: process.env,
+    shell: false,
+  })
+
+  if (r.error) {
+    console.error(`[fg-devkit] Could not open ${editor}: ${r.error.message}`)
+    return 1
+  }
+
+  return r.status ?? 1
+}
+
+async function main() {
+  if (!hasReleaseNotesConfig(cwd)) {
+    console.log('[fg-devkit] No release-notes config; skipping verification.')
+    return 0
+  }
+
+  while (true) {
+    showPreview()
+
+    const action = await select({
+      message: 'Granska release notes innan commit',
+      choices: [
+        { name: 'Godkänn och fortsätt', value: 'accept' },
+        { name: 'Hoppa över release notes (GitHub-genererade notes)', value: 'skip' },
+        { name: 'Redigera CHANGELOG.user.draft.md i $EDITOR', value: 'edit-draft' },
+        { name: 'Redigera CHANGELOG.user.md i $EDITOR', value: 'edit-user' },
+        { name: 'Synka user changelog efter redigering', value: 'sync' },
+        { name: 'Generera om från commits', value: 'regen' },
+        { name: 'Avbryt release', value: 'abort' },
+      ],
+      default: 'accept',
+      loop: false,
+    })
+
+    if (action === 'abort') {
+      console.log('[fg-devkit] Release avbruten.')
+      return 1
+    }
+
+    if (action === 'skip') {
+      console.log('[fg-devkit] Release notes hoppas över.')
+      return 2
+    }
+
+    if (action === 'regen') {
+      const code = runGenerateReleaseNotes()
+      if (code !== 0) {
+        return code
+      }
+      continue
+    }
+
+    if (action === 'edit-draft') {
+      const code = openEditor('CHANGELOG.user.draft.md')
+      if (code !== 0) {
+        return code
+      }
+      const syncCode = runSyncUserChangelog(cwd)
+      if (syncCode !== 0) {
+        return syncCode
+      }
+      continue
+    }
+
+    if (action === 'edit-user') {
+      const code = openEditor('CHANGELOG.user.md')
+      if (code !== 0) {
+        return code
+      }
+      continue
+    }
+
+    if (action === 'sync') {
+      const syncCode = runSyncUserChangelog(cwd)
+      if (syncCode !== 0) {
+        return syncCode
+      }
+      continue
+    }
+
+    const ok = await confirm({
+      message: 'Commit:a version + changelogs och skapa GitHub-release?',
+      default: true,
+    })
+
+    if (ok) {
+      return 0
+    }
+  }
+}
+
+const code = await main()
+process.exit(code)