@alleyinteractive/changelog-extractor 0.0.1 → 0.3.0

package/package.json

@@ -1,15 +1,24 @@
 {
   "name": "@alleyinteractive/changelog-extractor",
-  "version": "0.0.1",
+  "version": "0.3.0",
+  "type": "module",
   "description": "Parse and extract structured information from Keep a Changelog formatted changelogs",
   "main": "src/parser.js",
   "bin": {
-    "changelog-extractor": "./cli.js"
+    "changelog-extractor": "./src/cli.js"
   },
   "scripts": {
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage"
+    "build": "npm run prettier && npm run package",
+    "fix-and-build": "npm run prettier:fix && npm run package",
+    "package:watch": "npm run package -- --watch",
+    "package": "npx rollup --config rollup.config.js",
+    "prepublishOnly": "npm test",
+    "prettier:fix": "npx prettier --write .",
+    "prettier": "npx prettier --check .",
+    "release:major": "npm version major && npm publish --access public && git push --follow-tags",
+    "release:minor": "npm version minor && npm publish --access public && git push --follow-tags",
+    "release:patch": "npm version patch && npm publish --access public && git push --follow-tags",
+    "test": "NODE_OPTIONS=--experimental-vm-modules NODE_NO_WARNINGS=1 npx jest"
   },
   "keywords": [
     "changelog",
@@ -31,26 +40,27 @@
   "homepage": "https://github.com/alleyinteractive/action-changelog-extractor#readme",
   "files": [
     "src/",
+    "dist/",
     "cli.js",
+    "action.yml",
     "README.md",
     "LICENSE"
   ],
+  "exports": {
+    ".": "./dist/index.js"
+  },
   "devDependencies": {
+    "@jest/globals": "^30.2.0",
+    "@rollup/plugin-commonjs": "^29.0.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
     "@types/jest": "^29.5.12",
     "@types/node": "^20.11.24",
-    "jest": "^29.7.0"
+    "jest": "^30.2.0",
+    "prettier": "^3.6.2",
+    "prettier-eslint": "^16.4.2",
+    "rollup": "^4.53.3"
   },
   "dependencies": {
     "@actions/core": "^1.10.1"
-  },
-  "jest": {
-    "testEnvironment": "node",
-    "coverageDirectory": "coverage",
-    "collectCoverageFrom": [
-      "src/**/*.js"
-    ],
-    "testMatch": [
-      "**/__tests__/**/*.test.js"
-    ]
   }
 }

package/src/cli.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+
+/**
+ * Changelog Extractor CLI
+ *
+ * Parse and extract structured information from Keep a Changelog formatted files.
+ * Can be run via npx or installed globally.
+ *
+ * @package @alleyinteractive/changelog-extractor
+ * @author Alley Interactive
+ * @license GPL-3.0
+ */
+
+import fs from 'fs'
+import path from 'path'
+import { parseChangelog } from './parser.js'
+
+function printUsage() {
+  console.log(`
+Usage: npx @alleyinteractive/changelog-extractor [options]
+
+Options:
+  -f, --file <path>     Path to changelog file (default: CHANGELOG.md)
+  -v, --version <ver>   Specific version to extract (e.g., "1.14.0" or "v1.14.0")
+                        Leave empty to return all versions
+  -l, --list            List the count of versions found and exit
+  -h, --help            Show this help message
+
+Examples:
+  npx @alleyinteractive/changelog-extractor                      # Parse CHANGELOG.md, all versions
+  npx @alleyinteractive/changelog-extractor -l                   # Count versions in CHANGELOG.md
+  npx @alleyinteractive/changelog-extractor -v 1.14.0            # Extract specific version
+  npx @alleyinteractive/changelog-extractor -f /tmp/test.md      # Parse specific file
+  npx @alleyinteractive/changelog-extractor -f CHANGELOG.md -v 1.14.0  # Both options
+  changelog-extractor -l                                         # If installed globally
+`)
+}
+
+// Parse command line arguments
+const args = process.argv.slice(2)
+
+if (args.includes('--help') || args.includes('-h')) {
+  printUsage()
+  process.exit(0)
+}
+
+const listMode = args.includes('-l') || args.includes('--list')
+
+// Parse file option
+let changelogFile = 'CHANGELOG.md'
+const fileIndex = args.findIndex((arg) => arg === '-f' || arg === '--file')
+if (fileIndex !== -1 && args[fileIndex + 1]) {
+  changelogFile = args[fileIndex + 1]
+}
+
+// Parse version option
+let versionArg = null
+const versionIndex = args.findIndex(
+  (arg) => arg === '-v' || arg === '--version'
+)
+if (versionIndex !== -1 && args[versionIndex + 1]) {
+  versionArg = args[versionIndex + 1]
+}
+
+const version = versionArg
+
+// Read changelog file
+const changelogPath = path.resolve(process.cwd(), changelogFile)
+
+if (!fs.existsSync(changelogPath)) {
+  console.error(`❌ Error: Changelog file not found: ${changelogPath}`)
+  console.error(
+    '\nTip: You can create a test changelog at /tmp/test-changelog.md'
+  )
+  process.exit(1)
+}
+
+const changelogContent = fs.readFileSync(changelogPath, 'utf8')
+
+try {
+  const results = parseChangelog(changelogContent, version)
+
+  // List mode: just display count and exit
+  if (listMode) {
+    console.log(`${results.length}`)
+    process.exit(0)
+  }
+
+  // Parse changelog
+  console.log(`📖 Parsing: ${changelogPath}`)
+  console.log(`🎯 Version: ${versionArg || 'all versions'}`)
+  console.log('')
+
+  if (results.length === 0) {
+    console.log('⚠️  No changelog entries found')
+    process.exit(1)
+  }
+
+  console.log(`✅ Found ${results.length} version(s)\n`)
+  console.log('─'.repeat(80))
+
+  // Pretty print results
+  results.forEach((entry, index) => {
+    console.log(`\n📦 Version: ${entry.name}`)
+    console.log(
+      `📝 Sections: ${Object.keys(entry.sections).join(', ') || 'none'}`
+    )
+    console.log('')
+
+    // Print sections
+    for (const [sectionName, sectionContent] of Object.entries(
+      entry.sections
+    )) {
+      console.log(
+        `  ### ${sectionName.charAt(0).toUpperCase() + sectionName.slice(1)}`
+      )
+      console.log('')
+      // Indent content
+      const lines = sectionContent.split('\n')
+      lines.forEach((line) => console.log(`  ${line}`))
+      console.log('')
+    }
+
+    if (index < results.length - 1) {
+      console.log('─'.repeat(80))
+    }
+  })
+
+  // Output JSON at the end
+  console.log('\n' + '═'.repeat(80))
+  console.log('\n📋 JSON Output:\n')
+  console.log(JSON.stringify(results, null, 2))
+} catch (error) {
+  console.error('❌ Error parsing changelog:', error.message)
+  process.exit(1)
+}

package/src/index.js

@@ -1,47 +1,7 @@
-const fs = require('fs');
-const path = require('path');
-const { parseChangelog } = require('./parser');
-
 /**
- * Main action entry point
+ * The entrypoint for the action. This file simply imports and runs the action's
+ * main logic.
  */
-async function run(core) {
-  try {
-    // Get inputs
-    const changelogPath = core.getInput('changelog-path') || 'CHANGELOG.md';
-    const versionInput = core.getInput('version');
-
-    // Only pass version if explicitly specified, otherwise return all versions
-    const version = versionInput || null;
-
-    // Read changelog file
-    const fullPath = path.resolve(process.cwd(), changelogPath);
-
-    if (!fs.existsSync(fullPath)) {
-      throw new Error(`Changelog file not found: ${fullPath}`);
-    }
-
-    const changelogContent = fs.readFileSync(fullPath, 'utf8');
-
-    // Parse changelog
-    const results = parseChangelog(changelogContent, version);
-
-    if (results.length === 0) {
-      core.warning(`No changelog entries found${version ? ` for version ${version}` : ''}`);
-    }
-
-    // Set output as JSON string
-    core.setOutput('result', JSON.stringify(results));
-
-    // Log summary
-    core.info(`Parsed ${results.length} changelog ${results.length === 1 ? 'entry' : 'entries'}`);
-    for (const entry of results) {
-      core.info(`  - Version ${entry.name}: ${Object.keys(entry.sections).length} sections`);
-    }
-
-  } catch (error) {
-    core.setFailed(error.message);
-  }
-}
+import { run } from './main.js'
 
-module.exports = run;
+run()

package/src/main.js

@@ -0,0 +1,50 @@
+import * as core from '@actions/core'
+import fs from 'fs'
+import path from 'path'
+import { parseChangelog } from './parser.js'
+
+/**
+ * Main action entry point
+ */
+export async function run() {
+  try {
+    const changelogPath = core.getInput('changelog-path') || 'CHANGELOG.md'
+    const versionInput = core.getInput('version')
+
+    // Only pass version if explicitly specified, otherwise return all versions
+    const version = versionInput || null
+
+    // Read changelog file
+    const fullPath = path.resolve(process.cwd(), changelogPath)
+
+    if (!fs.existsSync(fullPath)) {
+      throw new Error(`Changelog file not found: ${fullPath}`)
+    }
+
+    const changelogContent = fs.readFileSync(fullPath, 'utf8')
+
+    // Parse changelog
+    const results = parseChangelog(changelogContent, version)
+
+    if (results.length === 0) {
+      core.warning(
+        `No changelog entries found${version ? ` for version ${version}` : ''}`
+      )
+    }
+
+    // Set output as JSON string
+    core.setOutput('result', JSON.stringify(results))
+
+    // Log summary
+    core.info(
+      `Parsed ${results.length} changelog ${results.length === 1 ? 'entry' : 'entries'}`
+    )
+    for (const entry of results) {
+      core.info(
+        `  - Version ${entry.name}: ${Object.keys(entry.sections).length} sections`
+      )
+    }
+  } catch (error) {
+    core.setFailed(error.message)
+  }
+}

package/src/parser.js

@@ -1,3 +1,83 @@
+/**
+ * Unwrap text that has been wrapped across multiple lines.
+ * This fixes changelog text that has been hard-wrapped for readability
+ * but should flow as continuous text.
+ *
+ * @param {string} text - The text content to unwrap
+ * @returns {string} The unwrapped text
+ */
+function unwrapText(text) {
+  const lines = text.split('\n')
+  const unwrappedLines = []
+
+  for (let i = 0; i < lines.length; i++) {
+    let currentLine = lines[i]
+
+    // Skip empty lines - preserve them as-is
+    if (currentLine.trim() === '') {
+      unwrappedLines.push(currentLine)
+      continue
+    }
+
+    // Collect continuation lines
+    let j = i + 1
+    while (j < lines.length) {
+      const nextLine = lines[j]
+
+      // Stop if next line is empty
+      if (nextLine.trim() === '') {
+        break
+      }
+
+      const trimmedCurrent = currentLine.trim()
+      const trimmedNext = nextLine.trim()
+
+      // Don't unwrap if current line looks like it ends a sentence/item
+      const endsWithPunctuation = /[.!?:;]$/.test(trimmedCurrent)
+      const endsWithCode = /`$/.test(trimmedCurrent)
+      const endsWithBullet = /[-*+]\s*$/.test(trimmedCurrent)
+
+      // Don't unwrap if next line starts a new bullet point, section, or sentence
+      const startsWithBullet = /^[-*+]\s/.test(trimmedNext)
+      const startsWithNumber = /^\d+\.\s/.test(trimmedNext)
+      const startsWithMarkdown = /^[#>]/.test(trimmedNext)
+
+      // More nuanced check for new sentences
+      const prevEndsWithContinuation =
+        /[,&]$/.test(trimmedCurrent) ||
+        /\b(and|or|but|with|for|to|from|in|on|at|by)$/.test(trimmedCurrent)
+      const startsWithCapitalNewSentence =
+        /^[A-Z]/.test(trimmedNext) &&
+        !prevEndsWithContinuation &&
+        endsWithPunctuation
+
+      // Determine if we should unwrap this line with the next
+      const shouldUnwrap =
+        !endsWithPunctuation &&
+        !endsWithCode &&
+        !endsWithBullet &&
+        !startsWithBullet &&
+        !startsWithNumber &&
+        !startsWithCapitalNewSentence &&
+        !startsWithMarkdown
+
+      if (shouldUnwrap) {
+        // Join the lines, preserving the original indentation of the first line
+        // but removing indentation from continuation lines
+        currentLine = currentLine + ' ' + trimmedNext
+        j++ // Move to next line
+      } else {
+        break // Stop unwrapping
+      }
+    }
+
+    unwrappedLines.push(currentLine)
+    i = j - 1 // Skip the lines we've consumed (j-1 because for loop will increment)
+  }
+
+  return unwrappedLines.join('\n')
+}
+
 /**
  * Parse a Keep a Changelog formatted changelog file.
  *
@@ -5,31 +85,31 @@
  * @param {string|null} version - Specific version to extract (e.g., "v1.14.0" or "1.14.0"), or null/undefined for all versions
  * @returns {Array<{name: string, sections: Object, contents: string}>} Array of version objects
  */
-function parseChangelog(changelogContent, version = null) {
-  const versions = [];
-  const lines = changelogContent.split('\n');
+export function parseChangelog(changelogContent, version = null) {
+  const versions = []
+  const lines = changelogContent.split('\n')
 
-  let currentVersion = null;
-  let currentSection = null;
-  let currentSectionContent = [];
-  let generalContent = []; // Content without section headers
+  let currentVersion = null
+  let currentSection = null
+  let currentSectionContent = []
+  let generalContent = [] // Content without section headers
 
   // Regex to match version headers: ## v1.14.0 or ## v1.14.0 - 2024-04-29
-  const versionRegex = /^##\s+v?(\d+\.\d+\.\d+(?:-[^\s]+)?)\s*(?:-\s*(.*))?$/;
+  const versionRegex = /^##\s+v?(\d+\.\d+\.\d+(?:-[^\s]+)?)\s*(?:-\s*(.*))?$/
   // Regex to match section headers: ### Added, ### Changed, etc.
-  const sectionRegex = /^###\s+(.+)$/;
+  const sectionRegex = /^###\s+(.+)$/
 
   for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
+    const line = lines[i]
 
     // Check for version header
-    const versionMatch = line.match(versionRegex);
+    const versionMatch = line.match(versionRegex)
     if (versionMatch) {
       // Save previous version if exists
       if (currentVersion) {
-        saveCurrentSection();
-        saveGeneralContent();
-        versions.push(currentVersion);
+        saveCurrentSection()
+        saveGeneralContent()
+        versions.push(currentVersion)
       }
 
       // Start new version
@@ -37,62 +117,70 @@ function parseChangelog(changelogContent, version = null) {
         name: versionMatch[1], // Version without 'v' prefix
         sections: {},
         contents: ''
-      };
-      currentSection = null;
-      currentSectionContent = [];
-      generalContent = [];
-      continue;
+      }
+      currentSection = null
+      currentSectionContent = []
+      generalContent = []
+      continue
     }
 
     // Check for section header
-    const sectionMatch = line.match(sectionRegex);
+    const sectionMatch = line.match(sectionRegex)
     if (sectionMatch && currentVersion) {
       // If we have general content, save it before starting a new section
       if (generalContent.length > 0) {
-        saveGeneralContent();
+        saveGeneralContent()
       }
 
       // Save previous section if exists
-      saveCurrentSection();
+      saveCurrentSection()
 
       // Start new section
-      currentSection = sectionMatch[1].toLowerCase();
-      currentSectionContent = [];
-      continue;
+      currentSection = sectionMatch[1].toLowerCase()
+      currentSectionContent = []
+      continue
     }
 
     // Add content to current section or general content
     if (currentVersion) {
       if (currentSection) {
-        currentSectionContent.push(line);
+        currentSectionContent.push(line)
       } else {
         // Content without a section header goes to general
-        generalContent.push(line);
+        generalContent.push(line)
       }
     }
   }
 
   // Save final version and section
   if (currentVersion) {
-    saveCurrentSection();
-    saveGeneralContent();
-    versions.push(currentVersion);
+    saveCurrentSection()
+    saveGeneralContent()
+    versions.push(currentVersion)
   }
 
   // Helper function to save the current section
   function saveCurrentSection() {
     if (currentVersion && currentSection && currentSectionContent.length > 0) {
       // Trim empty lines from start and end
-      while (currentSectionContent.length > 0 && currentSectionContent[0].trim() === '') {
-        currentSectionContent.shift();
+      while (
+        currentSectionContent.length > 0 &&
+        currentSectionContent[0].trim() === ''
+      ) {
+        currentSectionContent.shift()
       }
-      while (currentSectionContent.length > 0 && currentSectionContent[currentSectionContent.length - 1].trim() === '') {
-        currentSectionContent.pop();
+      while (
+        currentSectionContent.length > 0 &&
+        currentSectionContent[currentSectionContent.length - 1].trim() === ''
+      ) {
+        currentSectionContent.pop()
       }
 
-      const content = currentSectionContent.join('\n');
+      const content = currentSectionContent.join('\n')
       if (content.trim()) {
-        currentVersion.sections[currentSection] = content;
+        // Unwrap any text that has been hard-wrapped across lines
+        const unwrappedContent = unwrapText(content)
+        currentVersion.sections[currentSection] = unwrappedContent
       }
     }
   }
@@ -101,59 +189,73 @@ function parseChangelog(changelogContent, version = null) {
   function saveGeneralContent() {
     if (currentVersion && generalContent.length > 0) {
       // Trim empty lines from start and end
-      let trimmedContent = [...generalContent];
+      let trimmedContent = [...generalContent]
       while (trimmedContent.length > 0 && trimmedContent[0].trim() === '') {
-        trimmedContent.shift();
+        trimmedContent.shift()
       }
-      while (trimmedContent.length > 0 && trimmedContent[trimmedContent.length - 1].trim() === '') {
-        trimmedContent.pop();
+      while (
+        trimmedContent.length > 0 &&
+        trimmedContent[trimmedContent.length - 1].trim() === ''
+      ) {
+        trimmedContent.pop()
       }
 
-      const content = trimmedContent.join('\n');
+      const content = trimmedContent.join('\n')
       if (content.trim()) {
-        currentVersion.sections['general'] = content;
+        // Unwrap any text that has been hard-wrapped across lines
+        const unwrappedContent = unwrapText(content)
+        currentVersion.sections['general'] = unwrappedContent
       }
-      generalContent = [];
+      generalContent = []
     }
   }
 
   // Build contents for each version (all sections combined)
   for (const ver of versions) {
-    const contentParts = [];
+    const contentParts = []
 
     // Order sections in conventional order, with general at the end
-    const sectionOrder = ['added', 'changed', 'deprecated', 'removed', 'fixed', 'security'];
+    const sectionOrder = [
+      'added',
+      'changed',
+      'deprecated',
+      'removed',
+      'fixed',
+      'security'
+    ]
 
     for (const sectionName of sectionOrder) {
       if (ver.sections[sectionName]) {
-        contentParts.push(`### ${sectionName.charAt(0).toUpperCase() + sectionName.slice(1)}\n\n${ver.sections[sectionName]}`);
+        contentParts.push(
+          `### ${sectionName.charAt(0).toUpperCase() + sectionName.slice(1)}\n\n${ver.sections[sectionName]}`
+        )
       }
     }
 
     // Add any sections not in the standard order (except 'general')
     for (const [sectionName, sectionContent] of Object.entries(ver.sections)) {
       if (!sectionOrder.includes(sectionName) && sectionName !== 'general') {
-        contentParts.push(`### ${sectionName.charAt(0).toUpperCase() + sectionName.slice(1)}\n\n${sectionContent}`);
+        contentParts.push(
+          `### ${sectionName.charAt(0).toUpperCase() + sectionName.slice(1)}\n\n${sectionContent}`
+        )
       }
     }
 
     // Add general section last if it exists (without a header since it's raw content)
     if (ver.sections['general']) {
-      contentParts.push(ver.sections['general']);
+      contentParts.push(ver.sections['general'])
     }
 
-    ver.contents = contentParts.join('\n\n');
+    ver.contents = contentParts.join('\n\n')
   }
 
   // Filter by specific version if requested
   if (version) {
-    const normalizedVersion = version.replace(/^v/, ''); // Remove 'v' prefix if present
-    const filtered = versions.filter(v => v.name === normalizedVersion);
-    return filtered;
+    const normalizedVersion = version.replace(/^v/, '') // Remove 'v' prefix if present
+    const filtered = versions.filter((v) => v.name === normalizedVersion)
+    return filtered
   }
 
   // Return all versions by default
-  return versions;
+  return versions
 }
-
-module.exports = { parseChangelog };