MAJOR ENHANCEMENT: Add support for detecting minor/patch composer updates in addition to major updates

- Enhanced composer outdated detection to find best patch, minor, and major updates per package
- Uses 'composer show --available' to get all versions instead of just latest
- Now composer packages will appear in non-major PRs when safe updates are available
- Fixes the issue where only major updates were detected, missing safer bug fixes

Author: chrisbbreuer

src/buddy.ts

@@ -214,7 +214,7 @@ export class Buddy {
                 child.on('error', reject)
               })
             }
-            
+
             // Reset to clean main state before generating file updates
             await runGitCommand('git', ['checkout', 'main'])
             await runGitCommand('git', ['reset', '--hard', 'HEAD'])

src/registry/registry-client.ts

@@ -588,7 +588,7 @@ export class RegistryClient {
         this.logger.warn('Failed to read composer.json for dependency type detection:', error)
       }
 
-      // Parse composer outdated output and filter based on version constraints
+      // Parse composer outdated output and find multiple update paths per package
       if (composerData.installed) {
         for (const pkg of composerData.installed) {
           if (pkg.name && pkg.version && pkg.latest) {
@@ -601,23 +601,12 @@ export class RegistryClient {
               continue // Skip packages not found in composer.json
             }
 
-            // Include all available updates - let grouping and strategy handle filtering
-            const newVersion = pkg.latest
-
-            const updateType = getUpdateType(pkg.version, newVersion)
-
             // Skip ignored packages
             const ignoredPackages = this.config?.packages?.ignore || []
             if (ignoredPackages.includes(pkg.name)) {
               continue
             }
 
-            // Check if this is a major update and if major updates are excluded
-            const excludeMajor = this.config?.packages?.excludeMajor ?? false
-            if (excludeMajor && updateType === 'major') {
-              continue
-            }
-
             // Determine dependency type by checking composer.json
             let dependencyType: 'require' | 'require-dev' = 'require'
             if (composerJsonData['require-dev'] && composerJsonData['require-dev'][pkg.name]) {
@@ -627,18 +616,48 @@ export class RegistryClient {
             // Get additional metadata for the package
             const metadata = await this.getComposerPackageMetadata(pkg.name)
 
-            updates.push({
-              name: pkg.name,
-              currentVersion: pkg.version,
-              newVersion,
-              updateType,
-              dependencyType,
-              file: 'composer.json',
-              metadata,
-              releaseNotesUrl: this.getComposerReleaseNotesUrl(pkg.name, metadata),
-              changelogUrl: this.getComposerChangelogUrl(pkg.name, metadata),
-              homepage: metadata?.homepage,
-            })
+            // Find multiple update paths: patch, minor, and major
+            const currentVersion = pkg.version
+            const latestVersion = pkg.latest
+            
+            // Get all available versions by querying composer show
+            let availableVersions: string[] = []
+            try {
+              const showOutput = await this.runCommand('composer', ['show', pkg.name, '--available', '--format=json'])
+              const showData = JSON.parse(showOutput)
+              if (showData.versions) {
+                availableVersions = Object.keys(showData.versions)
+              }
+            } catch (error) {
+              console.warn(`Failed to get available versions for ${pkg.name}, using latest only:`, error)
+              availableVersions = [latestVersion]
+            }
+
+            // Find the best update for each type (patch, minor, major)
+            const updateCandidates = await this.findBestUpdates(currentVersion, availableVersions, constraint)
+
+            for (const candidate of updateCandidates) {
+              const updateType = getUpdateType(currentVersion, candidate.version)
+
+              // Check if this update type should be excluded
+              const excludeMajor = this.config?.packages?.excludeMajor ?? false
+              if (excludeMajor && updateType === 'major') {
+                continue
+              }
+
+              updates.push({
+                name: pkg.name,
+                currentVersion,
+                newVersion: candidate.version,
+                updateType,
+                dependencyType,
+                file: 'composer.json',
+                metadata,
+                releaseNotesUrl: this.getComposerReleaseNotesUrl(pkg.name, metadata),
+                changelogUrl: this.getComposerChangelogUrl(pkg.name, metadata),
+                homepage: metadata?.homepage,
+              })
+            }
           }
         }
       }
@@ -652,6 +671,95 @@ export class RegistryClient {
     }
   }
 
+  /**
+   * Find the best patch, minor, and major updates for a package
+   */
+  private async findBestUpdates(currentVersion: string, availableVersions: string[], constraint: string): Promise<{ version: string, type: 'patch' | 'minor' | 'major' }[]> {
+    const { getUpdateType } = await import('../utils/helpers')
+    const candidates: { version: string, type: 'patch' | 'minor' | 'major' }[] = []
+    
+    // Parse current version
+    const currentParts = this.parseVersion(currentVersion)
+    if (!currentParts) return []
+
+    let bestPatch: string | null = null
+    let bestMinor: string | null = null
+    let bestMajor: string | null = null
+
+    for (const version of availableVersions) {
+      // Skip dev/alpha/beta versions for now (could be enhanced later)
+      if (version.includes('dev') || version.includes('alpha') || version.includes('beta') || version.includes('RC')) {
+        continue
+      }
+
+      const versionParts = this.parseVersion(version)
+      if (!versionParts) continue
+
+      // Skip versions that are not newer
+      if (this.compareVersions(version, currentVersion) <= 0) {
+        continue
+      }
+
+      const updateType = getUpdateType(currentVersion, version)
+
+      // Find best update for each type
+      if (updateType === 'patch' && versionParts.major === currentParts.major && versionParts.minor === currentParts.minor) {
+        if (!bestPatch || this.compareVersions(version, bestPatch) > 0) {
+          bestPatch = version
+        }
+      } else if (updateType === 'minor' && versionParts.major === currentParts.major) {
+        if (!bestMinor || this.compareVersions(version, bestMinor) > 0) {
+          bestMinor = version
+        }
+      } else if (updateType === 'major') {
+        if (!bestMajor || this.compareVersions(version, bestMajor) > 0) {
+          bestMajor = version
+        }
+      }
+    }
+
+    // Add the best candidates
+    if (bestPatch) candidates.push({ version: bestPatch, type: 'patch' })
+    if (bestMinor) candidates.push({ version: bestMinor, type: 'minor' })
+    if (bestMajor) candidates.push({ version: bestMajor, type: 'major' })
+
+    return candidates
+  }
+
+  /**
+   * Parse a version string into major.minor.patch
+   */
+  private parseVersion(version: string): { major: number, minor: number, patch: number } | null {
+    // Remove 'v' prefix and any pre-release identifiers
+    const cleanVersion = version.replace(/^v/, '').split('-')[0].split('+')[0]
+    const parts = cleanVersion.split('.').map(p => parseInt(p, 10))
+    
+    if (parts.length < 2 || parts.some(p => isNaN(p))) {
+      return null
+    }
+    
+    return {
+      major: parts[0] || 0,
+      minor: parts[1] || 0,
+      patch: parts[2] || 0
+    }
+  }
+
+  /**
+   * Compare two version strings
+   * Returns: -1 if a < b, 0 if a === b, 1 if a > b
+   */
+  private compareVersions(a: string, b: string): number {
+    const parseA = this.parseVersion(a)
+    const parseB = this.parseVersion(b)
+    
+    if (!parseA || !parseB) return 0
+    
+    if (parseA.major !== parseB.major) return parseA.major - parseB.major
+    if (parseA.minor !== parseB.minor) return parseA.minor - parseB.minor
+    return parseA.patch - parseB.patch
+  }
+
   /**
    * Get Composer package metadata from Packagist
    */