npc release use shared release functions

Author: dwertheimer

scripts/releases.js

@@ -42,7 +42,10 @@ const path = require('path')
 const colors = require('chalk')
 const Messenger = require('@codedungeon/messenger')
 
+// Import shared release management utilities
 const { program } = require('commander')
+const releaseManagement = require('../src/commands/support/release-management')
+
 const { getFolderFromCommandLine, runShellCommand, getPluginFileContents, fileExists, getCopyTargetPath } = require('./shared')
 
 // Command line options
@@ -141,137 +144,8 @@ function getRelativeTime(publishedAt) {
   }
 }
 
-/**
- * Check if a version is a pre-release version (alpha, beta, rc, etc.)
- * @param {string} version - Version string
- * @returns {boolean} - True if pre-release
- */
-function isPreRelease(version) {
-  return /-(alpha|beta|rc|pre|dev|snapshot)/i.test(version)
-}
-
-/**
- * Get the base version from a pre-release version (removes pre-release identifier)
- * @param {string} version - Version string (e.g., "2.1.0-alpha.1")
- * @returns {string} - Base version (e.g., "2.1.0")
- */
-function getBaseVersion(version) {
-  return version.replace(/-.*$/, '')
-}
-
-/**
- * Check if a pre-release version has an obsolete stable counterpart
- * @param {string} preReleaseVersion - The pre-release version to check
- * @param {Array<{name: string, tag: string, version: string, publishedAt: string}>} allReleases - All releases
- * @param {number} monthsThreshold - Number of months after which stable version makes pre-release obsolete
- * @returns {boolean} - True if the pre-release is obsolete
- */
-function isPreReleaseObsolete(preReleaseVersion, allReleases, monthsThreshold = 3) {
-  const baseVersion = getBaseVersion(preReleaseVersion)
-  const now = new Date()
-  const thresholdDate = new Date(now.getTime() - monthsThreshold * 30 * 24 * 60 * 60 * 1000)
-
-  // Find the stable version of the same base version
-  const stableVersion = allReleases.find((release) => !isPreRelease(release.version) && getBaseVersion(release.version) === baseVersion)
-
-  if (!stableVersion) {
-    return false // No stable version found, keep the pre-release
-  }
-
-  // Check if the stable version was published more than the threshold ago
-  const stablePublishedDate = new Date(stableVersion.publishedAt)
-  return stablePublishedDate < thresholdDate
-}
-
-/**
- * Compare two version strings for sorting (semantic versioning)
- * @param {string} a - First version
- * @param {string} b - Second version
- * @returns {number} - Comparison result
- */
-function compareVersions(a, b) {
-  // Remove pre-release identifiers for comparison
-  const cleanA = a.replace(/-.*$/, '')
-  const cleanB = b.replace(/-.*$/, '')
-
-  const partsA = cleanA.split('.').map(Number)
-  const partsB = cleanB.split('.').map(Number)
-
-  const maxLength = Math.max(partsA.length, partsB.length)
-
-  for (let i = 0; i < maxLength; i++) {
-    const partA = partsA[i] || 0
-    const partB = partsB[i] || 0
-
-    if (partA !== partB) {
-      return partB - partA // Descending order (newest first)
-    }
-  }
-
-  // If versions are equal, put pre-release after stable
-  const aIsPre = isPreRelease(a)
-  const bIsPre = isPreRelease(b)
-
-  if (aIsPre && !bIsPre) return 1
-  if (!aIsPre && bIsPre) return -1
-
-  return 0
-}
-
-/**
- * Identify releases that should be pruned based on heuristics
- * @param {Array<{name: string, tag: string, version: string, publishedAt: string}>} releases - Array of releases
- * @returns {Array<{name: string, tag: string, version: string, publishedAt: string}>} - Releases to prune
- */
-function identifyReleasesToPrune(releases) {
-  if (releases.length <= 3) {
-    return [] // Keep at least 3 releases minimum
-  }
-
-  const now = new Date()
-  const sixMonthsAgo = new Date(now.getTime() - 6 * 30 * 24 * 60 * 60 * 1000)
-  const twoYearsAgo = new Date(now.getTime() - 2 * 365 * 24 * 60 * 60 * 1000)
-
-  // Sort releases by version (newest first)
-  const sortedReleases = [...releases].sort((a, b) => compareVersions(a.version, b.version))
-
-  const toPrune = []
-  const stableReleases = sortedReleases.filter((r) => !isPreRelease(r.version))
-  const preReleaseReleases = sortedReleases.filter((r) => isPreRelease(r.version))
-
-  // Keep the latest stable release
-  const latestStable = stableReleases[0]
-
-  // Keep the latest 2-3 pre-release versions if they're recent
-  const recentPreReleases = preReleaseReleases.filter((r) => new Date(r.publishedAt) >= sixMonthsAgo).slice(0, 3)
-
-  // Identify releases to prune
-  for (const release of releases) {
-    const isRecent = new Date(release.publishedAt) >= sixMonthsAgo
-    const isOld = new Date(release.publishedAt) < twoYearsAgo
-    const isLatestStable = release === latestStable
-    const isRecentPreRelease = recentPreReleases.includes(release)
-    const isObsoletePreRelease = isPreRelease(release.version) && isPreReleaseObsolete(release.version, releases)
-
-    // Prune if:
-    // 1. It's old (2+ years) AND not the latest stable
-    // 2. It's a pre-release that's obsolete (stable version published 3+ months ago)
-    // 3. It's a pre-release that's not recent and we have more than 5 pre-releases
-    // 4. It's not recent and not the latest stable and we have more than 5 total releases
-
-    if (isOld && !isLatestStable) {
-      toPrune.push(release)
-    } else if (isObsoletePreRelease) {
-      toPrune.push(release)
-    } else if (isPreRelease(release.version) && !isRecentPreRelease && preReleaseReleases.length > 5) {
-      toPrune.push(release)
-    } else if (!isRecent && !isLatestStable && releases.length > 5) {
-      toPrune.push(release)
-    }
-  }
-
-  return toPrune
-}
+// Use shared utility functions
+const { isPreRelease, getBaseVersion, isPreReleaseObsolete, compareVersions, identifyReleasesToPrune, generatePruneCommands } = releaseManagement
 
 /**
  * Identify releases to prune for duplicate version scenario (more lenient)
@@ -309,25 +183,6 @@ function identifyReleasesToPruneForDuplicate(releases) {
   return toPrune
 }
 
-/**
- * Generate prune commands for identified releases
- * @param {Array<{name: string, tag: string, version: string, publishedAt: string}>} releasesToPrune - Releases to prune
- * @returns {string} - Commands to run for pruning
- */
-function generatePruneCommands(releasesToPrune) {
-  if (releasesToPrune.length === 0) {
-    return 'No releases recommended for pruning.'
-  }
-
-  const commands = releasesToPrune.map((release) => `gh release delete "${release.tag}" -y`)
-
-  if (releasesToPrune.length === 1) {
-    return `Recommended prune command:\n${commands[0]}`
-  }
-
-  return `Recommended prune commands:\n${commands.join('\n')}\n\nTo prune all at once:\n${commands.join(' && ')}`
-}
-
 /**
  * Get all existing releases for a specific plugin
  * @param {string} pluginName - The plugin name to search for

src/commands/support/plugin-release.js

@@ -14,6 +14,7 @@ const { catchError, filter } = require('rxjs/operators')
 const streamToObservable = require('@samverschueren/stream-to-observable')
 const pluginUtils = require('./plugin-utils')
 const github = require('./github')
+const releaseManagement = require('./release-management')
 
 const prerequisiteTasks = require('./plugin-release/prerequisite-tasks')
 const gitTasks = require('./plugin-release/git-tasks')
@@ -28,27 +29,7 @@ const exec = (cmd, args) => {
   return merge(streamToObservable(cp.stdout.pipe(split())), streamToObservable(cp.stderr.pipe(split())), cp).pipe(filter(Boolean))
 }
 
-const buildDeleteCommands = async (pluginId = '', currentVersion = '') => {
-  const deleteCommands = []
-
-  const api = http.create({
-    baseURL: 'https://api.github.com',
-    headers: { Accept: 'application/vnd.github.v3+json' },
-  })
-
-  const releases = await api.get('repos/NotePlan/plugins/releases')
-  if (releases.data.length > 0) {
-    releases.data.forEach((release) => {
-      const tag = release.tag_name
-      if (tag.includes(pluginId) && !tag.includes(currentVersion)) {
-        const version = tag.replace(pluginId, '').replace('-v', '')
-        deleteCommands.push(`gh release delete "${pluginId}-v${version}" -y`)
-      }
-    })
-  }
-
-  return deleteCommands
-}
+// Removed buildDeleteCommands - no longer automatically deleting releases
 
 module.exports = {
   run: async (pluginId = '', pluginName = '', pluginVersion = '', args = {}) => {
@@ -68,25 +49,31 @@ module.exports = {
     const tasks = new Listr(
       [
         {
-          title: 'Prerequisite check',
+          title: 'Validating plugin files and structure',
           skip: () => {
             if (preview) {
-              return `[Preview] all validation`
+              return `[Preview] validate plugin files and structure`
             }
           },
           task: () => prerequisiteTasks(pluginId, args),
         },
         {
-          title: 'Github check',
+          title: 'Checking GitHub authentication and repository status',
           skip: () => {
             if (preview) {
-              return `[Preview] github tasks`
+              return `[Preview] check GitHub auth and repo status`
             }
           },
           task: () => gitTasks(pluginId, args),
         },
       ],
-      { showSubtaks: true },
+      {
+        renderer: 'default',
+        nonTTYRenderer: 'verbose',
+        collapse: false,
+        clearOutput: true,
+        showSubtasks: false,
+      },
     )
 
     tasks.add([
@@ -166,27 +153,23 @@ module.exports = {
       ])
     }
 
-    if (deletePrevious) {
-      tasks.add([
-        {
-          title: 'Deleting previous releases',
-          skip: async () => {
-            const cmds = await buildDeleteCommands(pluginId, pluginVersion)
-            if (args.preview) {
-              return `[Preview] ${(await cmds).join(', ')}`
-            }
-          },
-          task: async () => {
-            const cmds = await buildDeleteCommands(pluginId, pluginVersion)
-            if (cmds.length > 0) {
-              cmds.forEach(async (cmd) => {
-                const result = await system.run(cmd, true)
-              })
-            }
-          },
+    // Always check release history and show pruning recommendations
+    tasks.add([
+      {
+        title: 'Checking release history',
+        skip: () => {
+          if (args.preview) {
+            return `[Preview] Show pruning recommendations`
+          }
         },
-      ])
-    }
+        task: async () => {
+          // Collect release information but don't display it yet (to avoid interfering with Listr)
+          const releases = await releaseManagement.getExistingReleases(pluginId)
+          // Store the release info for display after Listr completes
+          return { releases, pluginId }
+        },
+      },
+    ])
 
     tasks.add([
       {
@@ -208,7 +191,55 @@ module.exports = {
       },
     ])
 
+    // Store release info to display after Listr completes
+    let releaseInfo = null
+
+    // Override the release history task to capture the data
+    const originalTasks = tasks._tasks
+    const releaseHistoryTask = originalTasks.find((task) => task.title === 'Checking release history')
+    if (releaseHistoryTask) {
+      const originalTask = releaseHistoryTask.task
+      releaseHistoryTask.task = async () => {
+        const releases = await releaseManagement.getExistingReleases(pluginId)
+        releaseInfo = { releases, pluginId }
+        return { releases, pluginId }
+      }
+    }
+
     const result = await tasks.run()
+
+    // Now display the release information after Listr has completed
+    if (releaseInfo) {
+      const { releases, pluginId: resultPluginId } = releaseInfo
+      if (releases && releases.length > 0) {
+        console.log('')
+        print.note(`Found ${releases.length} existing release(s) for plugin "${resultPluginId}":`)
+
+        // Get pruning recommendations
+        const releasesToPrune = releases.length > 3 ? releaseManagement.identifyReleasesToPrune(releases) : []
+        const pruneTags = new Set(releasesToPrune.map((r) => r.tag))
+
+        releases.forEach((release, index) => {
+          const publishedDate = new Date(release.publishedAt).toLocaleDateString()
+          const relativeTime = releaseManagement.getRelativeTime(release.publishedAt)
+          const shouldPrune = pruneTags.has(release.tag)
+          const pruneIndicator = shouldPrune ? ` ${colors.red('--PRUNE?')}` : ''
+
+          print.log(`  ${index + 1}. ${colors.cyan(release.tag)} (version ${release.version}, published ${publishedDate} -- ${relativeTime})${pruneIndicator}`)
+        })
+
+        if (releasesToPrune.length > 0) {
+          console.log('')
+          print.log(colors.cyan(releaseManagement.generatePruneCommands(releasesToPrune)))
+          console.log('')
+        } else if (releases.length <= 3) {
+          print.note(`Plugin has ${releases.length} releases (≤3), no pruning recommendations`)
+        }
+      } else {
+        print.note('No existing releases found for this plugin')
+      }
+    }
+
     console.log('')
     if (preview) {
       print.note(`${pluginId} v${pluginVersion} Released Successfully [PREVIEW]`, 'PREVIEW')