@logickernel/agileflow 0.2.2 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logickernel/agileflow",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "Automatic semantic versioning and changelog generation based on conventional commits",
   "main": "src/index.js",
   "bin": {

package/src/index.js

@@ -12,9 +12,9 @@ Usage:
 
 Commands:
   <none>   Prints the current version, next version, commits, and changelog
-  push     Push a semantic version tag to the remote repository (native git)
-  gitlab   Push a semantic version tag via GitLab API (for GitLab CI)
-  github   Push a semantic version tag via GitHub API (for GitHub Actions)
+  push     Push a semantic version tag to the remote repository
+  gitlab   Create a semantic version tag via GitLab API (for GitLab CI)
+  github   Create a semantic version tag via GitHub API (for GitHub Actions)
 
 Options:
   --quiet        Only output the next version (or empty if no bump)
@@ -26,11 +26,32 @@ For more information, visit: https://code.logickernel.com/tools/agileflow
 }
 
 /**
- * Parses command line arguments.
+ * Valid options that can be passed to commands.
+ */
+const VALID_OPTIONS = ['--quiet', '--help', '-h', '--version', '-v'];
+
+/**
+ * Valid commands.
+ */
+const VALID_COMMANDS = ['push', 'gitlab', 'github'];
+
+/**
+ * Parses command line arguments and validates them.
  * @param {Array<string>} args - Command line arguments
  * @returns {{quiet: boolean}}
+ * @throws {Error} If invalid options are found
  */
 function parseArgs(args) {
+  // Check for invalid options
+  for (const arg of args) {
+    if (arg.startsWith('--') && !VALID_OPTIONS.includes(arg)) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+    if (arg.startsWith('-') && !arg.startsWith('--') && !VALID_OPTIONS.includes(arg)) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  
   return {
     quiet: args.includes('--quiet'),
   };
@@ -61,7 +82,7 @@ function displayVersionInfo(info, quiet) {
   }
   
   console.log(`\nCurrent version: ${currentVersion || 'none'}`);
-  console.log(`New version: ${newVersion || 'no bump needed'}`);
+  console.log(`New version:     ${newVersion || 'no bump needed'}`);
   if (changelog) {
     console.log(`\nChangelog:\n\n${changelog}`);
   }
@@ -113,7 +134,17 @@ async function handlePushCommand(pushType, options) {
 
 async function main() {
   const [, , cmd, ...rest] = process.argv;
-  const options = parseArgs(cmd ? [cmd, ...rest] : rest);
+  
+  let options;
+  try {
+    options = parseArgs(cmd ? [cmd, ...rest] : rest);
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    console.error();
+    printHelp();
+    process.exit(1);
+    return;
+  }
 
   // Handle help
   if (cmd === '-h' || cmd === '--help' || cmd === 'help') {
@@ -134,13 +165,22 @@ async function main() {
   }
 
   // Unknown command (not an option)
-  if (cmd && !cmd.startsWith('--')) {
+  if (cmd && !cmd.startsWith('--') && !cmd.startsWith('-')) {
     console.error(`Error: Unknown command "${cmd}"`);
     console.error();
     printHelp();
     process.exit(1);
   }
 
+  // Invalid option (starts with -- but not valid)
+  if (cmd && cmd.startsWith('--') && !VALID_OPTIONS.includes(cmd)) {
+    console.error(`Error: Unknown option "${cmd}"`);
+    console.error();
+    printHelp();
+    process.exit(1);
+    return;
+  }
+
   // Default: show version info
   const info = await processVersionInfo();
   displayVersionInfo(info, options.quiet);

package/src/utils.js

@@ -170,13 +170,16 @@ function extractIssueReference(message) {
  * @param {string} subject - First line of commit message
  * @param {Object} parsed - Parsed conventional commit info
  * @param {string} fullMessage - Full commit message
+ * @param {boolean} isBreakingSection - Whether this is for the breaking changes section
  * @returns {string} Formatted description
  */
-function formatChangelogDescription(subject, parsed, fullMessage) {
+function formatChangelogDescription(subject, parsed, fullMessage, isBreakingSection = false) {
   if (!parsed) return subject;
   let description = parsed.description;
   const isBreaking = parsed.breaking || /BREAKING CHANGE:/i.test(fullMessage);
-  if (isBreaking) {
+  
+  // Only add BREAKING prefix if not in breaking changes section
+  if (isBreaking && !isBreakingSection) {
     description = `BREAKING: ${description}`;
   }
   return description;
@@ -229,13 +232,25 @@ function applyVersionBump(current, bump) {
   }
 }
 
+/**
+ * Checks if a commit is a breaking change.
+ * @param {Object} commit - Commit object
+ * @param {Object} parsed - Parsed conventional commit info
+ * @returns {boolean}
+ */
+function isBreakingChange(commit, parsed) {
+  if (!parsed) return false;
+  return parsed.breaking || /BREAKING CHANGE:/i.test(commit.message);
+}
+
 /**
  * Analyzes commits to determine version bump requirements.
  * @param {Array} commits - Array of commit objects
- * @returns {{hasBreaking: boolean, hasFeat: boolean, hasPatchTypes: boolean, commitsByType: Object}}
+ * @returns {{hasBreaking: boolean, hasFeat: boolean, hasPatchTypes: boolean, commitsByType: Object, breakingCommits: Array}}
  */
 function analyzeCommitsForVersioning(commits) {
   const commitsByType = Object.fromEntries(TYPE_ORDER.map(t => [t, []]));
+  const breakingCommits = [];
   let hasBreaking = false, hasFeat = false, hasPatchTypes = false;
   
   for (const commit of commits) {
@@ -243,18 +258,23 @@ function analyzeCommitsForVersioning(commits) {
     if (!parsed) continue;
     
     const { type, breaking } = parsed;
-    const isBreaking = breaking || /BREAKING CHANGE:/i.test(commit.message);
+    const isBreaking = isBreakingChange(commit, parsed);
     
-    if (isBreaking) hasBreaking = true;
-    if (type === 'feat') hasFeat = true;
-    else if (PATCH_TYPES.includes(type)) hasPatchTypes = true;
-    
-    if (commitsByType[type]) {
-      commitsByType[type].push(commit);
+    if (isBreaking) {
+      hasBreaking = true;
+      breakingCommits.push(commit);
+    } else {
+      // Only add to type sections if not breaking
+      if (type === 'feat') hasFeat = true;
+      else if (PATCH_TYPES.includes(type)) hasPatchTypes = true;
+      
+      if (commitsByType[type]) {
+        commitsByType[type].push(commit);
+      }
     }
   }
   
-  return { hasBreaking, hasFeat, hasPatchTypes, commitsByType };
+  return { hasBreaking, hasFeat, hasPatchTypes, commitsByType, breakingCommits };
 }
 
 /**
@@ -270,9 +290,10 @@ function capitalize(str) {
 /**
  * Generates changelog entries for a commit type section.
  * @param {Array} commits - Commits of this type
+ * @param {boolean} isBreakingSection - Whether this is for the breaking changes section
  * @returns {Array<string>} Changelog lines
  */
-function generateTypeChangelog(commits) {
+function generateTypeChangelog(commits, isBreakingSection = false) {
   const byScope = {};
   const noScope = [];
   
@@ -283,7 +304,7 @@ function generateTypeChangelog(commits) {
     const subject = commit.message.split('\n')[0].trim();
     const entry = {
       scope: parsed.scope,
-      description: formatChangelogDescription(subject, parsed, commit.message),
+      description: formatChangelogDescription(subject, parsed, commit.message, isBreakingSection),
       issueRef: extractIssueReference(commit.message) || '',
     };
     
@@ -323,6 +344,15 @@ function calculateNextVersionAndChangelog(expandedInfo) {
   
   // Generate changelog
   const changelogLines = [];
+  
+  // Add breaking changes section first if any
+  if (analysis.breakingCommits.length > 0) {
+    changelogLines.push('BREAKING CHANGES:');
+    changelogLines.push(...generateTypeChangelog(analysis.breakingCommits, true));
+    changelogLines.push('');
+  }
+  
+  // Add regular type sections
   for (const type of TYPE_ORDER) {
     const typeCommits = analysis.commitsByType[type];
     if (!typeCommits?.length) continue;