httpcat-cli 0.2.8-rc.1 → 0.2.9-rc.1

package/.github/workflows/release.yml

@@ -96,6 +96,18 @@ jobs:
               if (context.eventName === 'push' && context.payload.before) {
                 console.log(`Analyzing commits in this push (${context.payload.before}..${context.sha})...`);
                 try {
+                  // First, verify both commits exist
+                  try {
+                    await github.rest.repos.getCommit({
+                      owner: context.repo.owner,
+                      repo: context.repo.repo,
+                      ref: context.payload.before
+                    });
+                  } catch (e) {
+                    console.log(`⚠️  Base commit ${context.payload.before} not found (may have been squashed/rebased), falling back to last release`);
+                    throw new Error(`Base commit not found: ${e.message}`);
+                  }
+                  
                   const response = await github.rest.repos.compareCommits({
                     owner: context.repo.owner,
                     repo: context.repo.repo,
@@ -117,36 +129,29 @@ jobs:
                     }
                   }
                 } catch (e) {
-                  console.log(`⚠️  Could not compare commits in push, falling back to last release: ${e.message}`);
+                  console.log(`⚠️  Could not compare commits in push (${e.message}), falling back to last release`);
                   // Fallback to comparing with last release tag
                   if (lastTag) {
-                    let baseSha;
                     try {
-                      const { data: tagData } = await github.rest.git.getRef({
+                      // Use tag name directly - GitHub API resolves it to commit SHA
+                      const response = await github.rest.repos.compareCommits({
                         owner: context.repo.owner,
                         repo: context.repo.repo,
-                        ref: `tags/${lastTag}`
+                        base: lastTag,
+                        head: context.sha
                       });
-                      baseSha = tagData.object.sha;
+                      compareData = response.data;
                     } catch (e2) {
-                      try {
-                        const { data: commitData } = await github.rest.repos.getCommit({
-                          owner: context.repo.owner,
-                          repo: context.repo.repo,
-                          ref: lastTag
-                        });
-                        baseSha = commitData.sha;
-                      } catch (e3) {
-                        baseSha = null;
-                      }
+                      console.log(`⚠️  Tag comparison failed: ${e2.message}, using main branch`);
+                      // Final fallback to main branch
+                      const response = await github.rest.repos.compareCommits({
+                        owner: context.repo.owner,
+                        repo: context.repo.repo,
+                        base: 'main',
+                        head: context.sha
+                      });
+                      compareData = response.data;
                     }
-                    const response = await github.rest.repos.compareCommits({
-                      owner: context.repo.owner,
-                      repo: context.repo.repo,
-                      base: baseSha || 'main',
-                      head: context.sha
-                    });
-                    compareData = response.data;
                   } else {
                     // No last tag and push comparison failed - default to patch
                     // We can't reliably determine which commits to analyze without a baseline
@@ -159,33 +164,25 @@ jobs:
               } else if (lastTag) {
                 // For other events (like workflow_dispatch), compare with last release
                 console.log(`Last release tag: ${lastTag}`);
-                let baseSha;
                 try {
-                  const { data: tagData } = await github.rest.git.getRef({
+                  // Use tag name directly - GitHub API resolves it to commit SHA
+                  const response = await github.rest.repos.compareCommits({
                     owner: context.repo.owner,
                     repo: context.repo.repo,
-                    ref: `tags/${lastTag}`
+                    base: lastTag,
+                    head: context.sha
                   });
-                  baseSha = tagData.object.sha;
+                  compareData = response.data;
                 } catch (e) {
-                  try {
-                    const { data: commitData } = await github.rest.repos.getCommit({
-                      owner: context.repo.owner,
-                      repo: context.repo.repo,
-                      ref: lastTag
-                    });
-                    baseSha = commitData.sha;
-                  } catch (e2) {
-                    baseSha = null;
-                  }
+                  console.log(`⚠️  Tag comparison failed: ${e.message}, using main branch`);
+                  const response = await github.rest.repos.compareCommits({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    base: 'main',
+                    head: context.sha
+                  });
+                  compareData = response.data;
                 }
-                const response = await github.rest.repos.compareCommits({
-                  owner: context.repo.owner,
-                  repo: context.repo.repo,
-                  base: baseSha || 'main',
-                  head: context.sha
-                });
-                compareData = response.data;
               } else {
                 // No last tag and not a push event - default to patch
                 // For workflow_dispatch or other events without a tag, we can't reliably
@@ -325,40 +322,103 @@ jobs:
             const currentTag = 'v${{ steps.version.outputs.version }}';
 
             // Get commits since last release
+            let commits;
             let baseSha;
-            if (lastTag) {
+            
+            // For push events, prefer using context.payload.before if available
+            // This ensures we only get commits from the current push/merge
+            if (context.eventName === 'push' && context.payload.before) {
+              console.log(`Using push event comparison (${context.payload.before}..${context.sha})`);
               try {
-                const { data: tagData } = await github.rest.git.getRef({
+                const response = await github.rest.repos.compareCommits({
                   owner: context.repo.owner,
                   repo: context.repo.repo,
-                  ref: `tags/${lastTag}`
+                  base: context.payload.before,
+                  head: context.sha
                 });
-                baseSha = tagData.object.sha;
+                commits = response.data;
+                baseSha = context.payload.before;
+                console.log(`Found ${commits.commits.length} commits in this push`);
               } catch (e) {
-                // If tag ref doesn't exist, try to get commit from tag
-                const { data: tagData } = await github.rest.repos.getCommit({
-                  owner: context.repo.owner,
-                  repo: context.repo.repo,
-                  ref: lastTag
-                });
-                baseSha = tagData.sha;
+                console.log(`⚠️  Push comparison failed: ${e.message}, falling back to tag comparison`);
+                // Fall through to tag-based comparison
+              }
+            }
+            
+            // If push comparison didn't work or wasn't available, try tag-based comparison
+            if (!commits) {
+              if (lastTag) {
+                console.log(`Comparing with last tag ${lastTag}`);
+                
+                try {
+                  // Use the tag name directly - GitHub API will resolve it to the commit SHA
+                  // This handles both lightweight and annotated tags correctly
+                  const response = await github.rest.repos.compareCommits({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    base: lastTag,  // Use tag name directly, API resolves to commit
+                    head: context.sha
+                  });
+                  commits = response.data;
+                  baseSha = lastTag; // Store tag name for changelog link
+                  console.log(`Found ${commits.commits.length} commits since ${lastTag}`);
+                } catch (e) {
+                  console.log(`⚠️  Tag comparison failed: ${e.message}`);
+                  console.log(`Error details: ${e.response?.data?.message || e.message}`);
+                  
+                  // Try to get the actual commit SHA from the tag as fallback
+                  try {
+                    const { data: commitData } = await github.rest.repos.getCommit({
+                      owner: context.repo.owner,
+                      repo: context.repo.repo,
+                      ref: lastTag
+                    });
+                    const tagCommitSha = commitData.sha;
+                    console.log(`Resolved tag ${lastTag} to commit ${tagCommitSha}, retrying comparison...`);
+                    
+                    const response = await github.rest.repos.compareCommits({
+                      owner: context.repo.owner,
+                      repo: context.repo.repo,
+                      base: tagCommitSha,
+                      head: context.sha
+                    });
+                    commits = response.data;
+                    baseSha = tagCommitSha;
+                    console.log(`Found ${commits.commits.length} commits since ${lastTag}`);
+                  } catch (e2) {
+                    console.log(`⚠️  Commit SHA comparison also failed: ${e2.message}`);
+                    // Fall through to main branch comparison
+                  }
+                }
+              }
+              
+              // If tag comparison failed or no tag exists, compare with main branch
+              if (!commits) {
+                try {
+                  const { data: branchData } = await github.rest.repos.getBranch({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    branch: 'main'
+                  });
+                  baseSha = branchData.commit.sha;
+                  console.log(`Comparing with main branch (${baseSha})`);
+                  
+                  const response = await github.rest.repos.compareCommits({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    base: baseSha,
+                    head: context.sha
+                  });
+                  commits = response.data;
+                  console.log(`Found ${commits.commits.length} commits since main branch HEAD`);
+                } catch (e) {
+                  console.log(`⚠️  Main branch comparison also failed: ${e.message}`);
+                  console.log(`Using empty commit list - release notes will be minimal`);
+                  commits = { commits: [] };
+                  baseSha = null;
+                }
               }
-            } else {
-              // Get the first commit or main branch
-              const { data: branchData } = await github.rest.repos.getBranch({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                branch: 'main'
-              });
-              baseSha = branchData.commit.sha;
             }
-
-            const { data: commits } = await github.rest.repos.compareCommits({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              base: baseSha,
-              head: context.sha
-            });
 
             // Categorize commits
             const features = [];
@@ -367,21 +427,25 @@ jobs:
             const chore = [];
             const breaking = [];
 
-            for (const commit of commits.commits) {
-              const message = commit.commit.message;
-              const firstLine = message.split('\n')[0];
-              
-              if (firstLine.match(/^BREAKING/)) {
-                breaking.push(`- ${firstLine.replace(/^BREAKING[:\s]+/i, '')}`);
-              } else if (firstLine.match(/^feat(ure)?[(:]/i)) {
-                features.push(`- ${firstLine.replace(/^feat(ure)?[(:]\s*/i, '')}`);
-              } else if (firstLine.match(/^fix[(]/i)) {
-                fixes.push(`- ${firstLine.replace(/^fix[(]\s*/i, '')}`);
-              } else if (firstLine.match(/^doc(s)?[(]/i)) {
-                docs.push(`- ${firstLine.replace(/^doc(s)?[(]\s*/i, '')}`);
-              } else if (!firstLine.match(/^(chore|ci|test|build)[(:]/i)) {
-                chore.push(`- ${firstLine}`);
+            if (commits && commits.commits && commits.commits.length > 0) {
+              for (const commit of commits.commits) {
+                const message = commit.commit.message;
+                const firstLine = message.split('\n')[0];
+                
+                if (firstLine.match(/^BREAKING/)) {
+                  breaking.push(`- ${firstLine.replace(/^BREAKING[:\s]+/i, '')}`);
+                } else if (firstLine.match(/^feat(ure)?[(:]/i)) {
+                  features.push(`- ${firstLine.replace(/^feat(ure)?[(:]\s*/i, '')}`);
+                } else if (firstLine.match(/^fix[(]/i)) {
+                  fixes.push(`- ${firstLine.replace(/^fix[(]\s*/i, '')}`);
+                } else if (firstLine.match(/^doc(s)?[(]/i)) {
+                  docs.push(`- ${firstLine.replace(/^doc(s)?[(]\s*/i, '')}`);
+                } else if (!firstLine.match(/^(chore|ci|test|build)[(:]/i)) {
+                  chore.push(`- ${firstLine}`);
+                }
               }
+            } else {
+              console.log('⚠️  No commits found for release notes - using minimal release notes');
             }
 
             let notes = `## 🎉 Release ${{ steps.version.outputs.version }}\n\n`;
@@ -414,10 +478,13 @@ jobs:
             notes += `brew upgrade httpcat\n`;
             notes += `\`\`\`\n\n`;
             notes += `---\n\n`;
-            notes += `**Full Changelog**: https://github.com/${{ github.repository }}/compare/${lastTag || 'main'}...${currentTag}`;
+            
+            // Generate changelog link - use lastTag if available, otherwise use main
+            const changelogBase = lastTag || 'main';
+            notes += `**Full Changelog**: https://github.com/${{ github.repository }}/compare/${changelogBase}...${currentTag}`;
 
             core.setOutput('notes', notes);
-            console.log('Generated release notes');
+            console.log('✅ Generated release notes');
 
   # Job 2: Build and test
   test:

package/.github/workflows/sync-version.yml

@@ -1,13 +1,13 @@
 name: Sync Version to Develop
 
-# This workflow runs after a release to sync the version from main back to develop
+# This workflow runs after a release to reset develop to match main and sync the version
 on:
   release:
     types: [published]
 
 jobs:
   sync-version:
-    name: Sync version to develop
+    name: Reset develop to match main
     runs-on: ubuntu-latest
     permissions:
       contents: write
@@ -25,32 +25,87 @@ jobs:
           # Remove 'v' prefix if present
           VERSION="${VERSION#v}"
           echo "version=$VERSION" >> $GITHUB_OUTPUT
-          echo "✅ Version to sync: $VERSION"
+          echo "✅ Version from release: $VERSION"
 
       - name: Checkout develop branch
         run: |
           git checkout develop
           git pull origin develop
 
-      - name: Update package.json version
+      - name: Check for new commits in develop
+        id: check-commits
         run: |
-          VERSION="${{ steps.version.outputs.version }}"
-          npm version "$VERSION" --no-git-tag-version --allow-same-version
-          echo "✅ Updated package.json to version $VERSION"
+          # Check if develop has commits that aren't in main
+          COMMITS_AHEAD=$(git rev-list --count origin/main..HEAD 2>/dev/null || echo "0")
+          echo "commits_ahead=$COMMITS_AHEAD" >> $GITHUB_OUTPUT
+          
+          if [ "$COMMITS_AHEAD" -gt 0 ]; then
+            echo "ℹ️  Develop has $COMMITS_AHEAD commit(s) not in main"
+            echo "These will be preserved by rebasing onto main"
+          else
+            echo "✅ Develop has no new commits - can fast-forward to main"
+          fi
+
+      - name: Rebase develop onto main
+        run: |
+          echo "Updating develop to include latest from main..."
+          git fetch origin main
+          
+          # Check if we can fast-forward (no new commits in develop)
+          COMMITS_AHEAD="${{ steps.check-commits.outputs.commits_ahead }}"
+          
+          if [ "$COMMITS_AHEAD" -eq 0 ]; then
+            # Fast-forward: just move develop to main
+            echo "Fast-forwarding develop to main..."
+            git reset --hard origin/main
+          else
+            # Rebase: replay develop's commits on top of main
+            echo "Rebasing develop onto main..."
+            git rebase origin/main || {
+              echo "⚠️  Rebase conflict detected - this shouldn't happen if develop was properly merged"
+              echo "Falling back to reset (this will discard develop-only commits)"
+              git rebase --abort 2>/dev/null || true
+              git reset --hard origin/main
+            }
+          fi
+          echo "✅ Develop updated to include latest from main"
+
+      - name: Verify package.json version
+        run: |
+          CURRENT_VERSION=$(node -p "require('./package.json').version")
+          RELEASE_VERSION="${{ steps.version.outputs.version }}"
+          
+          echo "Current version in package.json: $CURRENT_VERSION"
+          echo "Release version: $RELEASE_VERSION"
+          
+          if [ "$CURRENT_VERSION" != "$RELEASE_VERSION" ]; then
+            echo "Updating package.json version..."
+            npm version "$RELEASE_VERSION" --no-git-tag-version --allow-same-version
+            git add package.json
+            git commit -m "chore: sync version to $RELEASE_VERSION" || echo "No changes to commit"
+          else
+            echo "✅ Version already matches"
+          fi
 
-      - name: Commit and push to develop
+      - name: Push to develop
         run: |
-          VERSION="${{ steps.version.outputs.version }}"
           git config user.name "github-actions[bot]"
           git config user.email "github-actions[bot]@users.noreply.github.com"
-          git add package.json
           
-          # Check if there are changes to commit
-          if git diff --staged --quiet; then
-            echo "✅ package.json already at version $VERSION, nothing to commit"
+          # Check if there are any changes to push
+          if git diff --quiet origin/develop HEAD; then
+            echo "✅ No changes to push (develop already up to date)"
           else
-            git commit -m "chore: sync version to $VERSION"
-            git push origin develop
-            echo "✅ Version synced to develop"
+            COMMITS_AHEAD="${{ steps.check-commits.outputs.commits_ahead }}"
+            if [ "$COMMITS_AHEAD" -eq 0 ]; then
+              # Fast-forward push (no force needed)
+              echo "Pushing fast-forward update..."
+              git push origin develop
+            else
+              # Rebase requires force push (but this is safe after rebase)
+              echo "Pushing rebased develop branch..."
+              git push origin develop --force-with-lease
+            fi
+            echo "✅ Develop updated and pushed"
           fi
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "httpcat-cli",
-  "version": "0.2.8-rc.1",
+  "version": "0.2.9-rc.1",
   "description": "CLI tool for interacting with httpcat agent - create, buy, and sell tokens with x402 payments",
   "main": "dist/index.js",
   "bin": {