abapgit-agent 1.3.0 → 1.5.0

package/scripts/release.js

@@ -0,0 +1,298 @@
+/**
+ * Release script - Creates release for github.com
+ *
+ * Usage: npm run release [--dry-run]
+ *
+ * Options:
+ *   --dry-run    Test the release flow without pushing to github.com
+ *
+ * This script:
+ * 1. Reads version from package.json
+ * 2. Updates the ABAP health resource with the new version
+ * 3. Uses Claude CLI to generate release notes from commits
+ * 4. Updates RELEASE_NOTES.md with new version notes
+ * 5. Pushes to github.com to trigger GitHub Actions (unless --dry-run)
+ * 6. GitHub Actions will publish to npm and create GitHub release
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const packageJsonPath = path.join(__dirname, '..', 'package.json');
+const abapHealthPath = path.join(__dirname, '..', 'abap', 'zcl_abgagt_resource_health.clas.abap');
+const releaseNotesPath = path.join(__dirname, '..', 'RELEASE_NOTES.md');
+const repoRoot = path.join(__dirname, '..');
+
+// Check for --dry-run flag
+const args = process.argv.slice(2);
+const dryRun = args.includes('--dry-run');
+
+if (dryRun) {
+  console.log('🔹 DRY RUN MODE - No actual release will be created\n');
+}
+
+// Read version from package.json
+const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+const version = pkg.version;
+
+console.log(`Current version: ${version}`);
+console.log('');
+
+// Check if version has been bumped - version must be greater than or equal to latest tag
+const allTags = execSync('git tag --sort=-v:refname', { cwd: repoRoot, encoding: 'utf8' });
+const tagList = allTags.trim().split('\n').filter(t => t.startsWith('v'));
+const latestTag = tagList[0] ? tagList[0].replace('v', '') : '';
+
+const versionTag = `v${version}`;
+
+if (version === latestTag) {
+  // Check if the tag points to HEAD (new release we just created)
+  try {
+    const tagRef = execSync(`git rev-parse ${versionTag}^{commit}`, { cwd: repoRoot, encoding: 'utf8' }).trim();
+    const headRef = execSync('git rev-parse HEAD', { cwd: repoRoot, encoding: 'utf8' }).trim();
+
+    if (tagRef !== headRef) {
+      console.log(`Version ${version} has already been released (tag v${version} exists on different commit)`);
+      console.log('');
+      console.log('To bump version, run one of:');
+      console.log('  npm version patch    # e.g., 1.4.0 -> 1.4.1');
+      console.log('  npm version minor    # e.g., 1.4.0 -> 1.5.0');
+      console.log('  npm version major    # e.g., 1.4.0 -> 2.0.0');
+      console.log('');
+      process.exit(1);
+    }
+    // If tag points to HEAD, this is the new release we just created - continue
+  } catch (e) {
+    // Tag doesn't exist - this is a new version
+  }
+}
+
+console.log(`Current version: ${version} (tag: ${versionTag})`);
+console.log('');
+
+// Check if there's a remote for github.com
+let remoteName = 'origin';
+try {
+  const remotes = execSync('git remote -v', { cwd: repoRoot, encoding: 'utf8' });
+  if (remotes.includes('github.com') && !remotes.includes('github.tools.sap')) {
+    remoteName = 'origin';
+  } else if (remotes.includes('public') && remotes.includes('github.com')) {
+    remoteName = 'public';
+  }
+  console.log(`Using remote: ${remoteName}`);
+} catch (e) {
+  console.log('Could not determine remote, using origin');
+}
+
+console.log('');
+
+// Read ABAP health resource file
+let abapContent = fs.readFileSync(abapHealthPath, 'utf8');
+
+// Update version in ABAP file (replace existing version)
+const oldVersionMatch = abapContent.match(/version":"(\d+\.\d+\.\d+)"/);
+if (oldVersionMatch) {
+  const oldVersion = oldVersionMatch[1];
+  abapContent = abapContent.replace(
+    `version":"${oldVersion}"`,
+    `version":"${version}"`
+  );
+
+  // Write updated content
+  fs.writeFileSync(abapHealthPath, abapContent);
+  console.log(`📦 ABAP version: ${oldVersion} -> ${version}`);
+  if (dryRun) {
+    console.log('   (file modified, not committed)');
+  }
+  console.log('');
+} else {
+  console.error('Could not find version in ABAP file');
+  process.exit(1);
+}
+
+// Get commits since last tag for release notes
+console.log('Generating release notes with Claude...');
+console.log('');
+
+let releaseNotesContent = '';
+
+try {
+  // Find previous tag
+  const allTags = execSync('git tag --sort=-v:refname', { cwd: repoRoot, encoding: 'utf8' });
+  const tagList = allTags.trim().split('\n').filter(t => t.startsWith('v'));
+  const previousTag = tagList[1] || 'HEAD~10';
+
+  // Get commits since last release
+  const commits = execSync(`git log ${previousTag}..HEAD --oneline`, { cwd: repoRoot, encoding: 'utf8' });
+
+  if (commits.trim()) {
+    console.log(`Found ${commits.trim().split('\n').length} commits since last release`);
+    console.log('');
+
+    // Create Claude prompt - escape for shell
+    const commitsEscaped = commits.replace(/"/g, '\\"').replace(/\n/g, '\\n');
+    const prompt = `Generate concise release notes for version ${version} of a Node.js CLI tool called abapgit-agent.
+
+Commits since last release:
+${commitsEscaped}
+
+Instructions:
+1. IGNORE commits that revert, undo, or remove previous changes
+2. IGNORE commits that fix/improve the release process itself
+3. Focus on actual USER-FACING features and fixes
+4. Use 2-4 bullet points MAX per category
+5. Keep each bullet brief (under 10 words)
+6. START your response with "## v${version}" and END with "---"
+7. OUTPUT ONLY the release notes - do NOT add any intro text, explanation, or commentary
+8. Use this exact format with blank lines between categories:
+## v${version}
+
+### New Features
+
+- Brief feature description
+
+### Bug Fixes
+
+- Brief fix description
+
+### Improvements
+
+- Brief improvement
+
+### Documentation
+
+- Brief doc update
+
+---
+
+OMIT any category that has no items.`;
+
+    // Call Claude CLI
+    try {
+      releaseNotesContent = execSync(`claude --print "${prompt}"`, { cwd: repoRoot, encoding: 'utf8', timeout: 60000 });
+      releaseNotesContent = releaseNotesContent.trim();
+      console.log('Generated release notes:');
+      console.log(releaseNotesContent);
+      console.log('');
+    } catch (e) {
+      console.log('Claude CLI not available, using fallback');
+      releaseNotesContent = `## v${version}\n\nSee commit history for changes.`;
+    }
+  } else {
+    console.log('No commits since last release');
+    releaseNotesContent = `## v${version}\n\nSee commit history for changes.`;
+  }
+} catch (e) {
+  console.log('Could not generate release notes:', e.message);
+  releaseNotesContent = `## v${version}\n\nSee commit history for changes.`;
+}
+
+// Show release notes in dry-run mode
+if (dryRun) {
+  console.log('📝 Generated Release Notes:');
+  console.log('─'.repeat(50));
+  console.log(releaseNotesContent);
+  console.log('─'.repeat(50));
+  console.log('');
+}
+
+// Update RELEASE_NOTES.md
+if (fs.existsSync(releaseNotesPath)) {
+  const existingContent = fs.readFileSync(releaseNotesPath, 'utf8');
+
+  // Check if version already exists
+  if (existingContent.includes(`## v${version}`)) {
+    console.log(`Release notes for v${version} already exist`);
+  } else {
+    let newContent;
+
+    // Check if there's a "# Release Notes" header - insert after it if present
+    if (existingContent.startsWith('# Release Notes')) {
+      // Find the position after "# Release Notes" and any following content
+      const lines = existingContent.split('\n');
+      let insertIndex = 0;
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i].match(/^## v\d+\.\d+\.\d+/)) {
+          insertIndex = i;
+          break;
+        }
+      }
+      // Insert new content before the first version header
+      const before = lines.slice(0, insertIndex).join('\n');
+      const after = lines.slice(insertIndex).join('\n');
+      newContent = before + '\n\n' + releaseNotesContent + '\n\n---\n\n' + after;
+    } else {
+      // Add new version at the top
+      newContent = releaseNotesContent + '\n\n---\n\n' + existingContent;
+    }
+
+    fs.writeFileSync(releaseNotesPath, newContent);
+    if (dryRun) {
+      console.log('📄 RELEASE_NOTES.md: would add new version at top');
+    } else {
+      console.log(`Updated RELEASE_NOTES.md with v${version}`);
+    }
+  }
+} else {
+  // Create new RELEASE_NOTES.md
+  fs.writeFileSync(releaseNotesPath, releaseNotesContent);
+  console.log(`Created RELEASE_NOTES.md with v${version}`);
+}
+console.log('');
+
+// Check git status and commit (skip in dry-run)
+const status = execSync('git status --porcelain', { cwd: repoRoot, encoding: 'utf8' });
+
+if (status.trim()) {
+  if (dryRun) {
+    console.log('🔹 DRY RUN - Would create commit with changes:');
+    console.log(status);
+    console.log('');
+  } else {
+    // Stage and commit
+    try {
+      execSync('git add abap/zcl_abgagt_resource_health.clas.abap package.json RELEASE_NOTES.md', { cwd: repoRoot });
+      execSync(`git commit -m "chore: release v${version}"`, { cwd: repoRoot });
+      console.log('Created git commit for version update');
+      console.log('');
+    } catch (e) {
+      console.log('No changes to commit or commit failed');
+    }
+  }
+} else {
+  console.log('No changes to commit (version already up to date)');
+  console.log('');
+}
+
+// Push to trigger GitHub Actions
+if (dryRun) {
+  console.log('🔹 DRY RUN - Skipping push to github.com');
+  console.log('');
+  console.log('To actually release, run:');
+  console.log(`  git push ${remoteName} master --follow-tags`);
+  console.log('');
+} else {
+  console.log('Pushing to github.com to trigger release...');
+  console.log('');
+
+  try {
+    // Push master and tags to github.com
+    execSync(`git push ${remoteName} master --follow-tags`, { cwd: repoRoot });
+    console.log('Pushed to github.com successfully!');
+    console.log('');
+  } catch (e) {
+    console.log('Push failed, please push manually');
+    console.log('');
+  }
+
+  console.log('Release workflow triggered!');
+  console.log('');
+  console.log('The GitHub Actions workflow will:');
+  console.log('1. Run tests');
+  console.log('2. Publish to npm');
+  console.log('3. Create GitHub release with Claude-generated notes');
+  console.log('');
+  console.log('Next step for ABAP system:');
+  console.log('  abapgit-agent pull --files abap/zcl_abgagt_resource_health.clas.abap');
+}

package/scripts/unrelease.js

@@ -0,0 +1,277 @@
+/**
+ * Unrelease script - Remove a release
+ *
+ * Usage: npm run unrelease [version] [--dry-run]
+ *
+ * Options:
+ *   --dry-run    Test the unrelease flow without making actual changes
+ *
+ * This script:
+ * 1. Takes a version as argument (default: current version from package.json)
+ * 2. Deletes the GitHub release
+ * 3. Deletes the git tag
+ * 4. Removes release notes from RELEASE_NOTES.md
+ * 5. Restores version in local files (or shows what would be restored in dry-run)
+ * 6. Removes release commits from git history (top 2 commits if they match release pattern)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const packageJsonPath = path.join(__dirname, '..', 'package.json');
+const releaseNotesPath = path.join(__dirname, '..', 'RELEASE_NOTES.md');
+const repoRoot = path.join(__dirname, '..');
+
+// Get version from argument or package.json
+let version = process.argv[2];
+
+// Check for --dry-run flag
+const args = process.argv.slice(2);
+const dryRun = args.includes('--dry-run');
+
+// Remove version and dry-run from args to get clean list
+const remainingArgs = args.filter(arg => arg !== '--dry-run' && !arg.startsWith('--'));
+if (!version && remainingArgs.length > 0) {
+  version = remainingArgs[0];
+}
+
+if (!version) {
+  const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  version = pkg.version;
+}
+
+// Ensure version has 'v' prefix for tag
+const versionTag = version.startsWith('v') ? version : `v${version}`;
+const versionNoV = version.startsWith('v') ? version.slice(1) : version;
+
+if (dryRun) {
+  console.log('🔹 DRY RUN MODE - No actual changes will be made\n');
+}
+
+console.log(`Unreleasing version: ${versionNoV} (tag: ${versionTag})`);
+console.log('');
+
+// Check if there's a remote for github.com
+let remoteName = 'origin';
+try {
+  const remotes = execSync('git remote -v', { cwd: repoRoot, encoding: 'utf8' });
+  if (remotes.includes('public') && remotes.includes('github.com')) {
+    remoteName = 'public';
+  }
+  console.log(`Using remote: ${remoteName}`);
+} catch (e) {
+  console.log('Could not determine remote, using origin');
+}
+
+console.log('');
+
+// Step 1: Delete GitHub release
+if (dryRun) {
+  console.log(`🔹 DRY RUN - Would delete GitHub release: ${versionTag}`);
+} else {
+  console.log('Deleting GitHub release...');
+  try {
+    execSync(`gh release delete ${versionTag} --repo SylvosCai/abapgit-agent --yes`, { cwd: repoRoot, encoding: 'utf8' });
+    console.log('✅ GitHub release deleted');
+  } catch (e) {
+    console.log('⚠️  GitHub release not found or already deleted');
+  }
+}
+console.log('');
+
+// Step 2: Delete git tag locally and remotely
+if (dryRun) {
+  console.log(`🔹 DRY RUN - Would delete git tag: ${versionTag}`);
+} else {
+  console.log('Deleting git tag...');
+  try {
+    execSync(`git tag -d ${versionTag}`, { cwd: repoRoot, encoding: 'utf8' });
+    console.log('✅ Local tag deleted');
+  } catch (e) {
+    console.log('⚠️  Local tag not found');
+  }
+
+  try {
+    execSync(`git push ${remoteName} --delete ${versionTag}`, { cwd: repoRoot, encoding: 'utf8' });
+    console.log('✅ Remote tag deleted');
+  } catch (e) {
+    console.log('⚠️  Remote tag not found or already deleted');
+  }
+}
+console.log('');
+
+// Step 3: Remove release notes from RELEASE_NOTES.md
+if (dryRun) {
+  console.log(`🔹 DRY RUN - Would remove release notes for v${versionNoV} from RELEASE_NOTES.md`);
+} else {
+  console.log('Removing release notes from RELEASE_NOTES.md...');
+  if (fs.existsSync(releaseNotesPath)) {
+    let content = fs.readFileSync(releaseNotesPath, 'utf8');
+
+    // Check if version exists in release notes
+    const versionHeader = `## v${versionNoV}`;
+    if (content.includes(versionHeader)) {
+      // Remove the version section (from ## vX.X.X to next --- or end)
+      const lines = content.split('\n');
+      const newLines = [];
+      let inVersionSection = false;
+      let foundVersion = false;
+
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+
+        // Match exactly the version header (e.g., ## v1.4.1)
+        if (line.trim() === versionHeader) {
+          inVersionSection = true;
+          foundVersion = true;
+          continue;
+        }
+
+        if (inVersionSection) {
+          // Stop at next --- separator or exact version header
+          if (line.startsWith('---')) {
+            inVersionSection = false;
+            newLines.push(line);
+          } else if (line.trim().startsWith('## v')) {
+            // Check if it's another exact version header (e.g., ## v1.4.0)
+            const trimmed = line.trim();
+            if (trimmed.match(/^## v\d+\.\d+\.\d+$/)) {
+              inVersionSection = false;
+              newLines.push(line);
+            }
+          }
+          // Otherwise skip this line (part of the version section)
+        } else {
+          newLines.push(line);
+        }
+      }
+
+      if (foundVersion) {
+        fs.writeFileSync(releaseNotesPath, newLines.join('\n').trim() + '\n');
+        console.log('✅ Release notes removed');
+      } else {
+        console.log('⚠️  Version not found in RELEASE_NOTES.md');
+      }
+    } else {
+      console.log('⚠️  Version not found in RELEASE_NOTES.md');
+    }
+  } else {
+    console.log('⚠️  RELEASE_NOTES.md not found');
+  }
+}
+console.log('');
+
+// Step 4: Restore version in package.json and abap health resource
+console.log('Restoring version in local files...');
+
+// Restore package.json to previous version (find previous tag)
+const allTags = execSync('git tag --sort=-v:refname', { cwd: repoRoot, encoding: 'utf8' });
+const tagList = allTags.trim().split('\n').filter(t => t.startsWith('v') && t !== versionTag);
+const previousTag = tagList[0];
+
+if (previousTag) {
+  // In dry-run mode, still restore files but don't commit
+  if (dryRun) {
+    try {
+      execSync(`git show ${previousTag}:package.json > ${packageJsonPath}`, { cwd: repoRoot, encoding: 'utf8' });
+      console.log(`🔹 DRY RUN - Restored package.json from ${previousTag}`);
+    } catch (e) {
+      console.log('⚠️  Could not restore package.json');
+    }
+
+    try {
+      execSync(`git show ${previousTag}:abap/zcl_abgagt_resource_health.clas.abap > abap/zcl_abgagt_resource_health.clas.abap`, { cwd: repoRoot, encoding: 'utf8' });
+      console.log(`🔹 DRY RUN - Restored ABAP health resource from ${previousTag}`);
+    } catch (e) {
+      console.log('⚠️  Could not restore ABAP health resource');
+    }
+  } else {
+    try {
+      execSync(`git show ${previousTag}:package.json > ${packageJsonPath}`, { cwd: repoRoot, encoding: 'utf8' });
+      console.log('✅ package.json restored to previous version');
+    } catch (e) {
+      console.log('⚠️  Could not restore package.json');
+    }
+
+    try {
+      execSync(`git show ${previousTag}:abap/zcl_abgagt_resource_health.clas.abap > abap/zcl_abgagt_resource_health.clas.abap`, { cwd: repoRoot, encoding: 'utf8' });
+      console.log('✅ ABAP health resource restored to previous version');
+    } catch (e) {
+      console.log('⚠️  Could not restore ABAP health resource');
+    }
+  }
+} else {
+  console.log('⚠️  No previous tag found, cannot restore version');
+}
+console.log('');
+
+// Step 5: Remove release commits from remote if they exist
+// Pattern: "chore: release vX.X.X" followed by "X.X.X"
+console.log('Checking for release commits on remote...');
+try {
+  // Get top 2 commit messages from remote
+  let remoteRef;
+  try {
+    remoteRef = execSync(`git rev-parse ${remoteName}/master 2>/dev/null`, { cwd: repoRoot, encoding: 'utf8' }).trim();
+  } catch (e) {
+    try {
+      remoteRef = execSync(`git rev-parse ${remoteName}/main 2>/dev/null`, { cwd: repoRoot, encoding: 'utf8' }).trim();
+    } catch (e2) {
+      remoteRef = '';
+    }
+  }
+
+  if (!remoteRef) {
+    console.log('⚠️  Could not determine remote ref');
+  } else {
+    // Get top 2 commits from remote
+    const remoteTopCommits = execSync(`git log ${remoteRef} -2 --format="%s"`, { cwd: repoRoot, encoding: 'utf8' }).trim().split('\n');
+
+    if (remoteTopCommits.length >= 2) {
+      const firstCommit = remoteTopCommits[0];  // Most recent on remote
+      const secondCommit = remoteTopCommits[1]; // Second most recent on remote
+
+      // Check if they match the expected pattern
+      // firstCommit (HEAD) = "chore: release vX.X.X"
+      // secondCommit (HEAD~1) = "X.X.X" (just version number)
+      const isReleaseCommit = firstCommit && firstCommit.match(/^chore: release v\d+\.\d+\.\d+$/);
+      const isVersionBump = secondCommit && secondCommit.match(/^\d+\.\d+\.\d+$/);
+
+      if (isReleaseCommit && isVersionBump) {
+        // Found release commits on remote - need to force push to remove them
+        // Find the commit to reset to (before the version bump)
+        const resetToRef = execSync(`git rev-parse ${remoteRef}~2`, { cwd: repoRoot, encoding: 'utf8' }).trim();
+
+        if (dryRun) {
+          console.log(`🔹 DRY RUN - Would force push to remove release commits from remote`);
+          console.log(`   Would remove: "${firstCommit}" and "${secondCommit}"`);
+          console.log(`   Would reset remote to: ${resetToRef.slice(0, 7)}`);
+        } else {
+          // Reset to the commit before release, then force push
+          execSync(`git reset --hard ${resetToRef}`, { cwd: repoRoot });
+          console.log('✅ Reset to commit before release');
+
+          // Force push to remove from remote
+          console.log('Force pushing to remote...');
+          execSync(`git push ${remoteName} +HEAD --force`, { cwd: repoRoot });
+          console.log('✅ Force pushed to remote - release commits removed from history');
+        }
+      } else {
+        console.log('⚠️  Remote top commits do not match release pattern, skipping');
+        console.log(`   Found: "${firstCommit}" and "${secondCommit}"`);
+      }
+    } else {
+      console.log('⚠️  Not enough commits on remote to check');
+    }
+  }
+} catch (e) {
+  console.log('⚠️  Could not check/remove release commits:', e.message);
+}
+console.log('');
+
+if (dryRun) {
+  console.log('🔹 DRY RUN COMPLETE - No actual changes made');
+} else {
+  console.log('Done!');
+}

package/src/abap-client.js

@@ -378,6 +378,24 @@ class ABAPClient {
 
     return await this.request('POST', '/tree', data, { csrfToken: this.csrfToken });
   }
+
+  async preview(objects, type = null, limit = 10) {
+    // Fetch CSRF token first
+    await this.fetchCsrfToken();
+
+    const data = {
+      objects: objects,
+      limit: Math.min(Math.max(1, limit), 100)
+    };
+
+    if (type) {
+      data.type = type;
+    }
+
+    logger.info('Previewing data', { objects, type, limit: data.limit, service: 'abapgit-agent' });
+
+    return await this.request('POST', '/preview', data, { csrfToken: this.csrfToken });
+  }
 }
 
 // Singleton instance

package/src/agent.js

@@ -53,7 +53,7 @@ class ABAPGitAgent {
       return {
         status: 'healthy',
         abap: 'connected',
-        version: result.version || '1.0.0'
+        version: result.version || '1.4.0'
       };
     } catch (error) {
       return {
@@ -191,6 +191,25 @@ class ABAPGitAgent {
       throw new Error(`Tree command failed: ${error.message}`);
     }
   }
+
+  async preview(objects, type = null, limit = 10) {
+    logger.info('Previewing data', { objects, type, limit });
+
+    try {
+      const result = await this.abap.preview(objects, type, limit);
+      return {
+        success: result.SUCCESS === 'X' || result.success === 'X' || result.success === true,
+        command: result.COMMAND || result.command || 'PREVIEW',
+        message: result.MESSAGE || result.message || '',
+        objects: result.OBJECTS || result.objects || [],
+        summary: result.SUMMARY || result.summary || null,
+        error: result.ERROR || result.error || null
+      };
+    } catch (error) {
+      logger.error('Preview command failed', { error: error.message });
+      throw new Error(`Preview command failed: ${error.message}`);
+    }
+  }
 }
 
 module.exports = {

package/src/config.js

@@ -33,7 +33,8 @@ function loadConfig() {
       password: process.env.ABAP_PASSWORD,
       language: process.env.ABAP_LANGUAGE || 'EN',
       gitUsername: process.env.GIT_USERNAME,
-      gitPassword: process.env.GIT_PASSWORD
+      gitPassword: process.env.GIT_PASSWORD,
+      transport: process.env.ABAP_TRANSPORT
     };
   }
 
@@ -59,8 +60,14 @@ function getAgentConfig() {
   return cfg.agent;
 }
 
+function getTransport() {
+  const cfg = loadConfig();
+  return cfg.transport;
+}
+
 module.exports = {
   loadConfig,
   getAbapConfig,
-  getAgentConfig
+  getAgentConfig,
+  getTransport
 };