@programinglive/commiter 1.1.0 → 1.1.3

package/package.json

@@ -1,94 +1,94 @@
-{
-  "name": "@programinglive/commiter",
-  "version": "1.1.0",
-  "description": "Commiter keeps repositories release-ready by enforcing conventional commits, generating icon-rich changelog entries, and orchestrating semantic version bumps without manual toil. It bootstraps Husky hooks, commitlint rules, and release scripts that inspect history, detect framework-specific test commands, run them automatically, tag git releases, coordinate npm publishing, surface release metrics, enforce project-specific checks, and give maintainers observability across distributed teams. Plus!",
-  "main": "index.js",
-  "bin": {
-    "commiter": "./index.js"
-  },
-  "scripts": {
-    "test": "node test/ensureSafeTestScript.test.js",
-    "prepare": "husky",
-    "release": "node scripts/release.js",
-    "release:major": "node scripts/release.js major",
-    "release:minor": "node scripts/release.js minor",
-    "release:patch": "node scripts/release.js patch"
-  },
-  "keywords": [
-    "commit",
-    "conventional-commits",
-    "standard-version",
-    "changelog",
-    "versioning",
-    "semantic-release",
-    "git-hooks",
-    "husky",
-    "commitlint"
-  ],
-  "author": "Programming Live",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/programinglive/commiter.git"
-  },
-  "bugs": {
-    "url": "https://github.com/programinglive/commiter/issues"
-  },
-  "homepage": "https://github.com/programinglive/commiter#readme",
-  "type": "commonjs",
-  "standard-version": {
-    "releaseCommitMessageFormat": "chore(release): {{currentTag}} 🚀",
-    "types": [
-      {
-        "type": "feat",
-        "section": "✨ Features"
-      },
-      {
-        "type": "fix",
-        "section": "🐛 Bug Fixes"
-      },
-      {
-        "type": "perf",
-        "section": "⚡ Performance"
-      },
-      {
-        "type": "refactor",
-        "section": "♻️ Refactors"
-      },
-      {
-        "type": "docs",
-        "section": "📝 Documentation"
-      },
-      {
-        "type": "style",
-        "section": "💄 Styles"
-      },
-      {
-        "type": "test",
-        "section": "✅ Tests"
-      },
-      {
-        "type": "build",
-        "section": "🏗️ Build System"
-      },
-      {
-        "type": "ci",
-        "section": "👷 Continuous Integration"
-      },
-      {
-        "type": "chore",
-        "section": "🧹 Chores"
-      },
-      {
-        "type": "revert",
-        "section": "⏪ Reverts"
-      }
-    ]
-  },
-  "devDependencies": {
-    "@commitlint/cli": "^20.1.0",
-    "@commitlint/config-conventional": "^20.0.0",
-    "husky": "^9.1.7",
-    "standard-version": "^9.5.0"
-  }
-}
+{
+  "name": "@programinglive/commiter",
+  "version": "1.1.3",
+  "description": "Commiter keeps repositories release-ready by enforcing conventional commits, generating icon-rich changelog entries, and orchestrating semantic version bumps without manual toil. It bootstraps Husky hooks, commitlint rules, and release scripts that inspect history, detect framework-specific test commands, run them automatically, tag git releases, coordinate npm publishing, surface release metrics, enforce project-specific checks, and give maintainers observability across distributed teams. Plus!",
+  "main": "index.js",
+  "bin": {
+    "commiter": "./index.js"
+  },
+  "scripts": {
+    "test": "node --test",
+    "prepare": "husky",
+    "release": "node scripts/release.js",
+    "release:major": "node scripts/release.js major",
+    "release:minor": "node scripts/release.js minor",
+    "release:patch": "node scripts/release.js patch"
+  },
+  "keywords": [
+    "commit",
+    "conventional-commits",
+    "standard-version",
+    "changelog",
+    "versioning",
+    "semantic-release",
+    "git-hooks",
+    "husky",
+    "commitlint"
+  ],
+  "author": "Programming Live",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/programinglive/commiter.git"
+  },
+  "bugs": {
+    "url": "https://github.com/programinglive/commiter/issues"
+  },
+  "homepage": "https://github.com/programinglive/commiter#readme",
+  "type": "commonjs",
+  "standard-version": {
+    "releaseCommitMessageFormat": "chore(release): {{currentTag}} 🚀",
+    "types": [
+      {
+        "type": "feat",
+        "section": "✨ Features"
+      },
+      {
+        "type": "fix",
+        "section": "🐛 Bug Fixes"
+      },
+      {
+        "type": "perf",
+        "section": "⚡ Performance"
+      },
+      {
+        "type": "refactor",
+        "section": "♻️ Refactors"
+      },
+      {
+        "type": "docs",
+        "section": "📝 Documentation"
+      },
+      {
+        "type": "style",
+        "section": "💄 Styles"
+      },
+      {
+        "type": "test",
+        "section": "✅ Tests"
+      },
+      {
+        "type": "build",
+        "section": "🏗️ Build System"
+      },
+      {
+        "type": "ci",
+        "section": "👷 Continuous Integration"
+      },
+      {
+        "type": "chore",
+        "section": "🧹 Chores"
+      },
+      {
+        "type": "revert",
+        "section": "⏪ Reverts"
+      }
+    ]
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^20.1.0",
+    "@commitlint/config-conventional": "^20.0.0",
+    "husky": "^9.1.7",
+    "standard-version": "^9.5.0"
+  }
+}

package/scripts/preload/fs-f-ok.cjs

@@ -0,0 +1,23 @@
+const fs = require('fs');
+const Module = require('module');
+
+const targetPath = require.resolve('standard-version/lib/lifecycles/changelog');
+
+if (!Module._commiterPatchedFsFok) {
+  const originalLoader = Module._extensions['.js'];
+
+  Module._extensions['.js'] = function patchedLoader(module, filename) {
+    if (filename === targetPath) {
+      let source = fs.readFileSync(filename, 'utf8');
+      if (source.includes('fs.F_OK')) {
+        source = source.replace(/fs\.F_OK/g, 'fs.constants.F_OK');
+      }
+      module._compile(source, filename);
+      return;
+    }
+
+    return originalLoader(module, filename);
+  };
+
+  Module._commiterPatchedFsFok = true;
+}

package/scripts/release.js

@@ -4,6 +4,13 @@ const { spawnSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 
+const { updateReleaseNotes } = require('./update-release-notes');
+
+const fsFokPreloadPath = path.join(__dirname, 'preload', 'fs-f-ok.cjs');
+const FS_FOK_PRELOAD_FLAG = buildPreloadFlag(fsFokPreloadPath);
+
+require('./preload/fs-f-ok.cjs');
+
 const VALID_RELEASE_TYPES = new Set([
   'major',
   'minor',
@@ -127,7 +134,13 @@ function runProjectTests({ spawn = spawnSync, env = process.env, cwd = process.c
   });
 }
 
-function runRelease({ argv = process.argv, env = process.env, spawn = spawnSync } = {}) {
+function runRelease({
+  argv = process.argv,
+  env = process.env,
+  spawn = spawnSync,
+  cwd = process.cwd(),
+  dependencies = {}
+} = {}) {
   const { releaseType: cliReleaseType, extraArgs } = getCliArguments(argv);
   const inferredReleaseType = cliReleaseType || getNpmRunArgument(env);
   const standardVersionArgs = buildStandardVersionArgs({
@@ -135,15 +148,89 @@ function runRelease({ argv = process.argv, env = process.env, spawn = spawnSync
     extraArgs
   });
 
+  const checkWorkingTreeClean = dependencies.isWorkingTreeClean || (() => isWorkingTreeClean({ cwd }));
+  const workingTreeClean = checkWorkingTreeClean();
+  if (!workingTreeClean) {
+    throw new Error('Working tree has uncommitted changes. Commit or stash before running release.');
+  }
+
   const testResult = runProjectTests({ spawn, env });
   if (testResult && typeof testResult.status === 'number' && testResult.status !== 0) {
     return testResult;
   }
 
   const standardVersionBin = require.resolve('standard-version/bin/cli.js');
-  return spawn(process.execPath, [standardVersionBin, ...standardVersionArgs], {
-    stdio: 'inherit'
+  const childEnv = appendPreloadToNodeOptions(env, FS_FOK_PRELOAD_FLAG);
+  const releaseResult = spawn(process.execPath, [standardVersionBin, ...standardVersionArgs], {
+    stdio: 'inherit',
+    env: childEnv,
+    cwd
+  });
+
+  if (releaseResult && typeof releaseResult.status === 'number' && releaseResult.status !== 0) {
+    return releaseResult;
+  }
+
+  const releaseNotesPath = dependencies.releaseNotesPath || path.join('docs', 'release-notes', 'RELEASE_NOTES.md');
+  const updateNotes = dependencies.updateReleaseNotes || ((options = {}) => updateReleaseNotes({ rootDir: cwd, ...options }));
+  const gitAdd = dependencies.gitAdd || ((files) => spawnSync('git', ['add', ...files], { stdio: 'inherit', cwd }));
+  const gitCommitAmend = dependencies.gitCommitAmend || (() => spawnSync('git', ['commit', '--amend', '--no-edit'], { stdio: 'inherit', cwd }));
+  const gitTag = dependencies.gitTag || ((tagName, tagMessage) => {
+    const args = tagMessage
+      ? ['tag', '-f', '-a', tagName, '-m', tagMessage]
+      : ['tag', '-f', tagName];
+    return spawnSync('git', args, { stdio: 'inherit', cwd });
   });
+  const getCommitMessage = dependencies.getCommitMessage || (() => spawnSync('git', ['log', '-1', '--pretty=%s'], { cwd, encoding: 'utf8' }));
+  const buildTagName = dependencies.buildTagName || ((version) => `v${version}`);
+  const loadPackage = dependencies.loadPackageJson || ((dir) => loadPackageJson(dir));
+
+  let notesUpdated = false;
+  try {
+    notesUpdated = updateNotes();
+  } catch (error) {
+    console.warn(`⚠️  Skipping release notes update: ${error.message}`);
+  }
+
+  if (notesUpdated) {
+    const gitAddResult = gitAdd([releaseNotesPath]);
+    if (!gitAddResult || typeof gitAddResult.status !== 'number' || gitAddResult.status !== 0) {
+      console.warn('⚠️  Release notes updated but failed to stage changes. Please add them manually.');
+      return releaseResult;
+    }
+
+    const gitCommitResult = gitCommitAmend();
+    if (!gitCommitResult || typeof gitCommitResult.status !== 'number' || gitCommitResult.status !== 0) {
+      console.warn('⚠️  Release notes updated but failed to amend release commit. Please amend manually.');
+      return releaseResult;
+    }
+
+    const packageJson = loadPackage(cwd);
+    const version = packageJson && packageJson.version;
+    if (!version) {
+      console.warn('⚠️  Cannot retag release: package.json version missing. Please update tag manually.');
+      return releaseResult;
+    }
+
+    const tagName = buildTagName(version);
+    let tagMessage;
+    try {
+      const commitMessageResult = getCommitMessage();
+      if (commitMessageResult && typeof commitMessageResult.status === 'number' && commitMessageResult.status === 0) {
+        const output = typeof commitMessageResult.stdout === 'string' ? commitMessageResult.stdout : '';
+        tagMessage = output.trim();
+      }
+    } catch (error) {
+      console.warn(`⚠️  Unable to read release commit message: ${error.message}`);
+    }
+
+    const gitTagResult = gitTag(tagName, tagMessage);
+    if (!gitTagResult || typeof gitTagResult.status !== 'number' || gitTagResult.status !== 0) {
+      console.warn(`⚠️  Failed to retag ${tagName}. Please update the tag manually before pushing.`);
+    }
+  }
+
+  return releaseResult;
 }
 
 if (require.main === module) {
@@ -167,5 +254,41 @@ module.exports = {
   loadPackageJson,
   detectPackageManager,
   runProjectTests,
-  runRelease
+  runRelease,
+  isWorkingTreeClean
 };
+
+function buildPreloadFlag(filePath) {
+  const resolved = path.resolve(filePath);
+  const escaped = resolved.includes(' ')
+    ? `"${resolved.replace(/"/g, '\"')}"`
+    : resolved;
+  return `--require ${escaped}`;
+}
+
+function appendPreloadToNodeOptions(env, preloadFlag) {
+  const nextEnv = { ...env };
+  const existing = typeof nextEnv.NODE_OPTIONS === 'string' ? nextEnv.NODE_OPTIONS.trim() : '';
+  nextEnv.NODE_OPTIONS = existing ? `${existing} ${preloadFlag}` : preloadFlag;
+  return nextEnv;
+}
+
+function isWorkingTreeClean({ cwd = process.cwd() } = {}) {
+  const result = spawnSync('git', ['status', '--porcelain'], {
+    cwd,
+    encoding: 'utf8'
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if (typeof result.status === 'number' && result.status !== 0) {
+    const stderr = typeof result.stderr === 'string' ? result.stderr.trim() : '';
+    const message = stderr || 'Failed to determine working tree status.';
+    throw new Error(message);
+  }
+
+  const output = typeof result.stdout === 'string' ? result.stdout : '';
+  return output.trim().length === 0;
+}

package/scripts/update-release-notes.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+function updateReleaseNotes({
+  rootDir = process.cwd(),
+  releaseNotesRelativePath = path.join('docs', 'release-notes', 'RELEASE_NOTES.md'),
+  changelogRelativePath = 'CHANGELOG.md',
+  packageJsonRelativePath = 'package.json',
+  now = () => new Date()
+} = {}) {
+  const releaseNotesPath = path.join(rootDir, releaseNotesRelativePath);
+  if (!fs.existsSync(releaseNotesPath)) {
+    console.log(`ℹ️  Release notes file not found at ${releaseNotesPath}; skipping update.`);
+    return false;
+  }
+
+  const packageJsonPath = path.join(rootDir, packageJsonRelativePath);
+  if (!fs.existsSync(packageJsonPath)) {
+    console.log(`ℹ️  package.json not found at ${packageJsonPath}; skipping release notes update.`);
+    return false;
+  }
+
+  const changelogPath = path.join(rootDir, changelogRelativePath);
+  if (!fs.existsSync(changelogPath)) {
+    console.log(`ℹ️  CHANGELOG not found at ${changelogPath}; skipping release notes update.`);
+    return false;
+  }
+
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  const version = packageJson.version;
+  if (!version) {
+    console.log('ℹ️  package.json version is missing; skipping release notes update.');
+    return false;
+  }
+
+  const releaseNotesContent = fs.readFileSync(releaseNotesPath, 'utf8');
+  if (releaseNotesContent.includes(`| ${version} `) || releaseNotesContent.includes(`## ${version}`)) {
+    console.log(`ℹ️  Release notes already contain version ${version}; skipping.`);
+    return false;
+  }
+
+  const changelogContent = fs.readFileSync(changelogPath, 'utf8');
+  const changelogInfo = extractChangelogInfo({ changelogContent, version });
+
+  const releaseDate = changelogInfo.date || formatDate(now());
+  const highlight = changelogInfo.highlight || changelogInfo.heading || 'See CHANGELOG for details.';
+  const sectionHeading = changelogInfo.heading || '';
+  const detailBullets = Array.isArray(changelogInfo.bullets) && changelogInfo.bullets.length > 0
+    ? changelogInfo.bullets
+    : [highlight];
+
+  const updatedContent = insertReleaseNotesEntry({
+    content: releaseNotesContent,
+    version,
+    releaseDate,
+    highlight,
+    sectionHeading,
+    detailBullets
+  });
+
+  fs.writeFileSync(releaseNotesPath, updatedContent);
+  console.log(`✅ Added release notes entry for version ${version}.`);
+  return true;
+}
+
+function insertReleaseNotesEntry({ content, version, releaseDate, highlight, sectionHeading, detailBullets }) {
+  const lines = content.split('\n');
+  const headerSeparatorIndex = lines.findIndex((line) => line.trim().startsWith('|---------'));
+  if (headerSeparatorIndex === -1) {
+    throw new Error('Unable to locate release notes table header.');
+  }
+
+  const newRow = `| ${version} | ${releaseDate} | ${escapePipes(highlight)} |`;
+  lines.splice(headerSeparatorIndex + 1, 0, newRow);
+
+  const sectionLines = [];
+  sectionLines.push('');
+  const trimmedHeading = typeof sectionHeading === 'string' ? sectionHeading.trim() : '';
+  const headingSuffix = trimmedHeading ? ` – ${trimmedHeading}` : '';
+  sectionLines.push(`## ${version}${headingSuffix}`);
+  sectionLines.push('');
+  sectionLines.push(`Released on **${releaseDate}**.`);
+  sectionLines.push('');
+  for (const bullet of detailBullets) {
+    sectionLines.push(`- ${bullet}`);
+  }
+  sectionLines.push('');
+
+  const firstSectionIndex = lines.findIndex((line, idx) => idx > headerSeparatorIndex && line.startsWith('## '));
+  if (firstSectionIndex === -1) {
+    lines.push(...sectionLines);
+  } else {
+    lines.splice(firstSectionIndex, 0, ...sectionLines);
+  }
+
+  return lines.join('\n');
+}
+
+function extractChangelogInfo({ changelogContent, version }) {
+  const versionHeadingRegex = new RegExp(`^### \\[${escapeRegExp(version)}\\][^\n]*`, 'm');
+  const match = changelogContent.match(versionHeadingRegex);
+  if (!match) {
+    return {};
+  }
+
+  const headingIndex = match.index;
+  const rest = changelogContent.slice(headingIndex + match[0].length);
+  const nextVersionRegex = /^### \[[^\n]*\]/m;
+  const nextVersionMatch = nextVersionRegex.exec(rest);
+  const section = nextVersionMatch ? rest.slice(0, nextVersionMatch.index) : rest;
+
+  const dateMatch = match[0].match(/\((\d{4}-\d{2}-\d{2})\)/);
+  const date = dateMatch ? dateMatch[1] : undefined;
+
+  const categoryRegex = /^###\s+([^\n]+)$/m;
+  const categoryMatch = section.match(categoryRegex);
+  let heading;
+  if (categoryMatch) {
+    heading = sanitizeText(categoryMatch[1]);
+  }
+
+  const bullets = [];
+  const bulletRegex = /^\*\s+([^\n]+)$/gm;
+  let bulletMatch;
+  while ((bulletMatch = bulletRegex.exec(section)) !== null) {
+    const sanitized = sanitizeText(bulletMatch[1]);
+    if (!bullets.includes(sanitized)) {
+      bullets.push(sanitized);
+    }
+  }
+
+  const highlight = bullets.length > 0 ? bullets[0] : undefined;
+
+  return {
+    date,
+    highlight,
+    heading,
+    bullets
+  };
+}
+
+function sanitizeText(text) {
+  return text
+    .replace(/\[([^\]]+)\]\([^\)]+\)/g, '$1')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function escapePipes(text) {
+  return text.replace(/\|/g, '\\|');
+}
+
+function formatDate(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  return `${year}-${month}-${day}`;
+}
+
+module.exports = {
+  updateReleaseNotes,
+  insertReleaseNotesEntry,
+  extractChangelogInfo,
+  sanitizeText,
+  escapePipes,
+  formatDate
+};
+
+if (require.main === module) {
+  try {
+    updateReleaseNotes();
+  } catch (error) {
+    console.error(`❌ Failed to update release notes: ${error.message}`);
+    process.exit(1);
+  }
+}