abapgit-agent 1.8.6 → 1.8.8

package/bin/abapgit-agent

@@ -24,7 +24,7 @@ const gitUtils = require('../src/utils/git-utils');
 const versionCheck = require('../src/utils/version-check');
 const validators = require('../src/utils/validators');
 const { AbapHttp } = require('../src/utils/abap-http');
-const { loadConfig, getTransport, isAbapIntegrationEnabled } = require('../src/config');
+const { loadConfig, getTransport, isAbapIntegrationEnabled, getSafeguards } = require('../src/config');
 
 // Get terminal width for responsive table
 const getTermWidth = () => process.stdout.columns || 80;
@@ -52,7 +52,8 @@ async function main() {
     where: require('../src/commands/where'),
     ref: require('../src/commands/ref'),
     init: require('../src/commands/init'),
-    pull: require('../src/commands/pull')
+    pull: require('../src/commands/pull'),
+    upgrade: require('../src/commands/upgrade')
   };
 
   // Check if this is a modular command
@@ -98,11 +99,17 @@ To enable integration:
       isAbapIntegrationEnabled,
       loadConfig,
       AbapHttp,
-      getTransport
+      getTransport,
+      getSafeguards
     };
 
     // Execute command
     await cmd.execute(args.slice(1), context);
+
+    // Show new version reminder (non-blocking, cached daily)
+    if (command !== 'upgrade') {
+      await versionCheck.showNewVersionReminder();
+    }
     return;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abapgit-agent",
-  "version": "1.8.6",
+  "version": "1.8.8",
   "description": "ABAP Git Agent - Pull and activate ABAP code via abapGit from any git repository",
   "main": "src/index.js",
   "files": [
@@ -33,6 +33,7 @@
     "test:cmd:view": "node tests/run-all.js --cmd --command=view",
     "test:cmd:preview": "node tests/run-all.js --cmd --command=preview",
     "test:cmd:tree": "node tests/run-all.js --cmd --command=tree",
+    "test:cmd:upgrade": "node tests/run-all.js --cmd --command=upgrade",
     "test:lifecycle": "node tests/run-all.js --lifecycle",
     "test:pull": "node tests/run-all.js --pull",
     "pull": "node bin/abapgit-agent",

package/src/commands/import.js

@@ -120,9 +120,15 @@ Examples:
         resultData = { filesStaged: 'unknown', commitMessage: commitMessage };
       }
 
+      if (resultData.success !== 'X' && resultData.success !== true) {
+        const errorMsg = resultData.error || resultData.ERROR || 'Unknown error';
+        console.log(`❌ Import failed: ${errorMsg}`);
+        process.exit(1);
+      }
+
       console.log(`✅ Import completed successfully!`);
-      console.log(`   Files staged: ${resultData.filesStaged || resultData.FILES_STAGED || 'unknown'}`);
-      console.log(`   Commit: ${resultData.commitMessage || resultData.COMMIT_MESSAGE || commitMessage || 'Initial import'}`);
+      console.log(`   Files staged: ${resultData.filesStaged || resultData.FILES_STAGED || resultData.files_staged || 'unknown'}`);
+      console.log(`   Commit: ${resultData.commitMessage || resultData.COMMIT_MESSAGE || resultData.commit_message || commitMessage || 'Initial import'}`);
       console.log(``);
 
       // Calculate time spent

package/src/commands/pull.js

@@ -9,7 +9,21 @@ module.exports = {
   requiresVersionCheck: true,
 
   async execute(args, context) {
-    const { loadConfig, AbapHttp, gitUtils, getTransport } = context;
+    const { loadConfig, AbapHttp, gitUtils, getTransport, getSafeguards } = context;
+
+    // Check project-level safeguards
+    const safeguards = getSafeguards();
+
+    // SAFEGUARD 1: Check if pull is completely disabled
+    if (safeguards.disablePull) {
+      console.error('❌ Error: pull command is disabled for this project\n');
+      if (safeguards.reason) {
+        console.error(`Reason: ${safeguards.reason}\n`);
+      }
+      console.error('The pull command has been disabled in .abapgit-agent.json');
+      console.error('Please contact the project maintainer to enable it.');
+      process.exit(1);
+    }
 
     const urlArgIndex = args.indexOf('--url');
     const branchArgIndex = args.indexOf('--branch');
@@ -36,6 +50,18 @@ module.exports = {
       files = args[filesArgIndex + 1].split(',').map(f => f.trim());
     }
 
+    // SAFEGUARD 2: Check if files are required but not provided
+    if (safeguards.requireFilesForPull && !files) {
+      console.error('❌ Error: --files parameter is required for this project\n');
+      if (safeguards.reason) {
+        console.error(`Reason: ${safeguards.reason}\n`);
+      }
+      console.error('Usage: abapgit-agent pull --files <file1>,<file2>\n');
+      console.error('This safeguard is configured in .abapgit-agent.json');
+      console.error('Contact the project maintainer if you need to change this setting.');
+      process.exit(1);
+    }
+
     if (!gitUrl) {
       gitUrl = gitUtils.getRemoteUrl();
       if (!gitUrl) {

package/src/commands/upgrade.js

@@ -0,0 +1,456 @@
+/**
+ * Upgrade command - Upgrade CLI and/or ABAP backend to latest or specific version
+ */
+
+const { execSync } = require('child_process');
+const readline = require('readline');
+
+module.exports = {
+  name: 'upgrade',
+  description: 'Upgrade CLI and/or ABAP backend to latest or specific version',
+  requiresAbapConfig: false,  // Checked conditionally
+  requiresVersionCheck: false, // Does its own version checks
+
+  async execute(args, context) {
+    const { versionCheck, loadConfig, isAbapIntegrationEnabled } = context;
+
+    // Parse flags
+    const flags = this.parseFlags(args);
+
+    // Validate flag combinations
+    try {
+      this.validateFlags(flags);
+    } catch (error) {
+      console.error(`❌ Error: ${error.message}`);
+      process.exit(1);
+    }
+
+    // Check if ABAP config is needed
+    const needsAbapConfig = !flags.cliOnly && !flags.checkOnly;
+    if (needsAbapConfig && !isAbapIntegrationEnabled()) {
+      console.error('❌ Error: .abapGitAgent config file not found');
+      console.error('   ABAP upgrade requires configuration.');
+      console.error('   Run: abapgit-agent init');
+      console.error('');
+      console.error('   Or use --cli-only to upgrade CLI package only.');
+      process.exit(1);
+    }
+
+    // Get current versions
+    const cliVersion = versionCheck.getCliVersion();
+    let abapVersion = null;
+
+    if (needsAbapConfig) {
+      try {
+        const config = loadConfig();
+        const { apiVersion } = await versionCheck.checkCompatibility(config);
+        abapVersion = apiVersion;
+      } catch (e) {
+        console.error(`⚠️  Could not fetch ABAP version: ${e.message}`);
+      }
+    }
+
+    // Get latest version from npm
+    const latestVersion = await versionCheck.getLatestNpmVersion();
+    if (!latestVersion && !flags.version && !flags.match) {
+      console.error('❌ Error: Could not fetch latest version from npm registry');
+      console.error('   Please check your internet connection or specify --version X.X.X');
+      process.exit(1);
+    }
+
+    // Validate specified version exists in npm registry
+    if (flags.version && !flags.abapOnly) {
+      const versionExists = await this.validateVersionExists(flags.version);
+      if (!versionExists) {
+        console.error(`❌ Error: Version ${flags.version} not found in npm registry`);
+        console.error('   Please check available versions at: https://www.npmjs.com/package/abapgit-agent?activeTab=versions');
+        process.exit(1);
+      }
+    }
+
+    // Determine target versions
+    const targets = this.determineTargets(flags, cliVersion, abapVersion, latestVersion);
+
+    // Check-only mode
+    if (flags.checkOnly) {
+      this.showCheckReport(cliVersion, abapVersion, latestVersion);
+      return;
+    }
+
+    // Dry-run mode
+    if (flags.dryRun) {
+      this.showDryRunPlan(cliVersion, abapVersion, targets, flags);
+      return;
+    }
+
+    // Show upgrade plan
+    if (!flags.yes) {
+      const proceed = await this.confirmUpgrade(cliVersion, abapVersion, targets, flags);
+      if (!proceed) {
+        console.log('Upgrade cancelled.');
+        return;
+      }
+    }
+
+    // Execute upgrade
+    await this.performUpgrade(targets, flags, context);
+
+    // Verify upgrade
+    await this.verifyUpgrade(targets, flags, context);
+  },
+
+  /**
+   * Parse command-line flags
+   */
+  parseFlags(args) {
+    return {
+      checkOnly: args.includes('--check'),
+      cliOnly: args.includes('--cli-only'),
+      abapOnly: args.includes('--abap-only'),
+      match: args.includes('--match'),
+      version: this.getArgValue(args, '--version'),
+      latest: args.includes('--latest'),
+      yes: args.includes('--yes') || args.includes('-y'),
+      dryRun: args.includes('--dry-run'),
+      transport: this.getArgValue(args, '--transport')
+    };
+  },
+
+  /**
+   * Get argument value following a flag
+   */
+  getArgValue(args, flag) {
+    const index = args.indexOf(flag);
+    if (index !== -1 && index + 1 < args.length) {
+      return args[index + 1];
+    }
+    return null;
+  },
+
+  /**
+   * Validate flag combinations
+   */
+  validateFlags(flags) {
+    // Invalid combinations
+    if (flags.match && flags.version) {
+      throw new Error('Cannot use --match and --version together');
+    }
+
+    if (flags.match && flags.cliOnly) {
+      throw new Error('Cannot use --match with --cli-only. --match upgrades ABAP to match CLI version');
+    }
+
+    if (flags.cliOnly && flags.abapOnly) {
+      throw new Error('Cannot use --cli-only and --abap-only together');
+    }
+  },
+
+  /**
+   * Validate that a version exists in npm registry
+   */
+  async validateVersionExists(version) {
+    return new Promise((resolve) => {
+      const { execSync } = require('child_process');
+      try {
+        // Use npm view to check if version exists
+        const output = execSync(`npm view abapgit-agent@${version} version 2>/dev/null`, {
+          encoding: 'utf8',
+          stdio: ['pipe', 'pipe', 'ignore']
+        }).trim();
+
+        // If npm view returns the version, it exists
+        resolve(output === version);
+      } catch (e) {
+        // Version doesn't exist or npm command failed
+        resolve(false);
+      }
+    });
+  },
+
+  /**
+   * Determine target versions for CLI and ABAP
+   */
+  determineTargets(flags, cliVersion, abapVersion, latestVersion) {
+    let cliTarget = null;
+    let abapTarget = null;
+
+    if (flags.match) {
+      // Match ABAP to CLI version
+      abapTarget = cliVersion;
+    } else if (flags.version) {
+      // Specific version
+      cliTarget = flags.cliOnly ? flags.version : (flags.abapOnly ? null : flags.version);
+      abapTarget = flags.abapOnly ? flags.version : (flags.cliOnly ? null : flags.version);
+    } else {
+      // Latest version (default)
+      cliTarget = flags.abapOnly ? null : latestVersion;
+      abapTarget = flags.cliOnly ? null : latestVersion;
+    }
+
+    return { cliTarget, abapTarget };
+  },
+
+  /**
+   * Show check-only report
+   */
+  showCheckReport(cliVersion, abapVersion, latestVersion) {
+    console.log('');
+    console.log('Current versions:');
+    console.log(`  CLI:  v${cliVersion}`);
+    if (abapVersion) {
+      console.log(`  ABAP: v${abapVersion}`);
+    }
+    console.log('');
+
+    if (latestVersion) {
+      console.log(`Latest available: v${latestVersion}`);
+      console.log('');
+    }
+
+    const needsCliUpgrade = latestVersion && cliVersion !== latestVersion;
+    const needsAbapUpgrade = abapVersion && latestVersion && abapVersion !== latestVersion;
+    const versionMismatch = abapVersion && cliVersion !== abapVersion;
+
+    if (versionMismatch) {
+      console.log('⚠️  Version mismatch detected');
+      console.log('');
+    } else if (!needsCliUpgrade && !needsAbapUpgrade) {
+      console.log('✅ All components are up to date');
+      console.log('');
+      return;
+    }
+
+    console.log('To upgrade:');
+    console.log('  Both:      abapgit-agent upgrade');
+    console.log('  CLI only:  abapgit-agent upgrade --cli-only');
+    if (abapVersion) {
+      console.log('  ABAP only: abapgit-agent upgrade --abap-only');
+      console.log('  Match:     abapgit-agent upgrade --match');
+    }
+    console.log('');
+  },
+
+  /**
+   * Show dry-run plan
+   */
+  showDryRunPlan(cliVersion, abapVersion, targets, flags) {
+    console.log('');
+    console.log('🔹 DRY RUN - No changes will be made');
+    console.log('');
+    console.log('Current versions:');
+    console.log(`  CLI:  v${cliVersion}`);
+    if (abapVersion) {
+      console.log(`  ABAP: v${abapVersion}`);
+    }
+    console.log('');
+
+    console.log('Target versions:');
+    if (targets.cliTarget) {
+      console.log(`  CLI:  v${targets.cliTarget}`);
+    }
+    if (targets.abapTarget) {
+      console.log(`  ABAP: v${targets.abapTarget}`);
+    }
+    console.log('');
+
+    console.log('Would execute:');
+    let step = 1;
+    if (targets.cliTarget) {
+      console.log(`  ${step}. npm install -g abapgit-agent@${targets.cliTarget}`);
+      step++;
+    }
+    if (targets.abapTarget) {
+      console.log(`  ${step}. abapgit-agent pull --branch v${targets.abapTarget}`);
+      console.log('     (via existing abapGit repository)');
+      step++;
+    }
+    console.log(`  ${step}. Verify versions match`);
+    console.log('');
+    console.log('No changes made.');
+    console.log('');
+  },
+
+  /**
+   * Confirm upgrade with user
+   */
+  async confirmUpgrade(cliVersion, abapVersion, targets, flags) {
+    console.log('');
+    console.log('📦 Upgrade Plan:');
+    console.log('');
+    console.log('Current versions:');
+    console.log(`  CLI:  v${cliVersion}`);
+    if (abapVersion) {
+      console.log(`  ABAP: v${abapVersion}`);
+    }
+    console.log('');
+
+    console.log('Target versions:');
+    if (targets.cliTarget) {
+      console.log(`  CLI:  v${targets.cliTarget}`);
+    }
+    if (targets.abapTarget) {
+      console.log(`  ABAP: v${targets.abapTarget}`);
+    }
+    console.log('');
+
+    console.log('This will:');
+    let step = 1;
+    if (targets.cliTarget) {
+      console.log(`  ${step}. Upgrade npm package: abapgit-agent@${targets.cliTarget}`);
+      step++;
+    }
+    if (targets.abapTarget) {
+      console.log(`  ${step}. Pull ABAP code from git tag v${targets.abapTarget}`);
+      step++;
+      console.log(`  ${step}. Activate all backend components`);
+      step++;
+    }
+    console.log('');
+
+    return new Promise((resolve) => {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+
+      rl.question('Do you want to continue? [Y/n] ', (answer) => {
+        rl.close();
+        const normalized = answer.trim().toLowerCase();
+        resolve(normalized === '' || normalized === 'y' || normalized === 'yes');
+      });
+    });
+  },
+
+  /**
+   * Perform upgrade
+   */
+  async performUpgrade(targets, flags, context) {
+    console.log('');
+    console.log('🚀 Starting upgrade...');
+    console.log('');
+
+    // Upgrade CLI
+    if (targets.cliTarget) {
+      await this.upgradeCliPackage(targets.cliTarget);
+    }
+
+    // Upgrade ABAP
+    if (targets.abapTarget) {
+      await this.upgradeAbapBackend(targets.abapTarget, flags.transport, context);
+    }
+  },
+
+  /**
+   * Upgrade CLI package via npm
+   */
+  async upgradeCliPackage(version) {
+    console.log(`📦 Upgrading CLI to v${version}...`);
+
+    try {
+      // Check if npm is available
+      try {
+        execSync('npm --version', { stdio: 'ignore' });
+      } catch (e) {
+        console.error('❌ Error: npm is not installed or not in PATH');
+        console.error('   Please install Node.js and npm: https://nodejs.org/');
+        process.exit(1);
+      }
+
+      // Run npm install
+      const command = `npm install -g abapgit-agent@${version}`;
+      console.log(`   Running: ${command}`);
+
+      execSync(command, {
+        stdio: 'inherit',
+        encoding: 'utf8'
+      });
+
+      console.log(`✅ CLI upgraded to v${version}`);
+      console.log('');
+    } catch (error) {
+      console.error(`❌ Failed to upgrade CLI: ${error.message}`);
+      console.error('');
+      console.error('This may be due to:');
+      console.error('  - Version not found in npm registry');
+      console.error('  - Permission issues (try with sudo)');
+      console.error('  - Network connectivity issues');
+      process.exit(1);
+    }
+  },
+
+  /**
+   * Upgrade ABAP backend via pull command
+   */
+  async upgradeAbapBackend(version, transport, context) {
+    console.log(`📦 Upgrading ABAP backend to v${version}...`);
+    console.log(`   Using git tag: v${version}`);
+    console.log('');
+
+    try {
+      // Build pull command args
+      const pullArgs = ['--branch', `v${version}`];
+      if (transport) {
+        pullArgs.push('--transport', transport);
+      }
+
+      // Execute pull command
+      const pullCommand = require('./pull');
+      await pullCommand.execute(pullArgs, context);
+
+      console.log('');
+      console.log(`✅ ABAP backend upgraded to v${version}`);
+      console.log('');
+    } catch (error) {
+      console.error(`❌ Failed to upgrade ABAP backend: ${error.message}`);
+      console.error('');
+      console.error('This may be due to:');
+      console.error('  - Git tag not found in repository');
+      console.error('  - ABAP activation errors');
+      console.error('  - Connection issues with ABAP system');
+      process.exit(1);
+    }
+  },
+
+  /**
+   * Verify upgrade success
+   */
+  async verifyUpgrade(targets, flags, context) {
+    console.log('🔍 Verifying upgrade...');
+    console.log('');
+
+    const { versionCheck, loadConfig } = context;
+
+    // Check CLI version
+    let cliVersion = null;
+    if (targets.cliTarget) {
+      cliVersion = versionCheck.getCliVersion();
+      if (cliVersion === targets.cliTarget) {
+        console.log(`✅ CLI version verified: v${cliVersion}`);
+      } else {
+        console.log(`⚠️  CLI version mismatch: expected v${targets.cliTarget}, got v${cliVersion}`);
+        console.log('   You may need to restart your terminal or reinstall globally');
+      }
+    }
+
+    // Check ABAP version
+    if (targets.abapTarget && !flags.cliOnly) {
+      try {
+        const config = loadConfig();
+        const { apiVersion: abapVersion } = await versionCheck.checkCompatibility(config);
+
+        if (abapVersion === targets.abapTarget) {
+          console.log(`✅ ABAP version verified: v${abapVersion}`);
+        } else {
+          console.log(`⚠️  ABAP version mismatch: expected v${targets.abapTarget}, got v${abapVersion}`);
+          console.log('   Some components may have failed to activate');
+        }
+      } catch (e) {
+        console.log(`⚠️  Could not verify ABAP version: ${e.message}`);
+      }
+    }
+
+    console.log('');
+    console.log('✅ Upgrade complete!');
+    console.log('');
+  }
+};

package/src/config.js

@@ -88,11 +88,67 @@ function getWorkflowConfig() {
   };
 }
 
+/**
+ * Load project-level configuration (.abapgit-agent.json)
+ * This file is checked into version control and contains project settings
+ * @returns {Object|null} Project config or null if not found
+ */
+function loadProjectConfig() {
+  const projectConfigPath = path.join(process.cwd(), '.abapgit-agent.json');
+
+  if (fs.existsSync(projectConfigPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(projectConfigPath, 'utf8'));
+    } catch (error) {
+      console.warn(`⚠️  Warning: Failed to parse .abapgit-agent.json: ${error.message}`);
+      return null;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get safeguard configuration from project-level config
+ * Project-level safeguards CANNOT be overridden by user config
+ * @returns {Object} Safeguards config with requireFilesForPull, disablePull, and reason
+ */
+function getSafeguards() {
+  const projectConfig = loadProjectConfig();
+
+  if (projectConfig?.safeguards) {
+    return {
+      requireFilesForPull: projectConfig.safeguards.requireFilesForPull === true,
+      disablePull: projectConfig.safeguards.disablePull === true,
+      reason: projectConfig.safeguards.reason || null
+    };
+  }
+
+  // Default: no safeguards (backward compatible)
+  return {
+    requireFilesForPull: false,
+    disablePull: false,
+    reason: null
+  };
+}
+
+/**
+ * Get project information from project-level config
+ * @returns {Object|null} Project info (name, description) or null
+ */
+function getProjectInfo() {
+  const projectConfig = loadProjectConfig();
+  return projectConfig?.project || null;
+}
+
 module.exports = {
   loadConfig,
   getAbapConfig,
   getAgentConfig,
   getTransport,
   isAbapIntegrationEnabled,
-  getWorkflowConfig
+  getWorkflowConfig,
+  getSafeguards,
+  getProjectInfo,
+  loadProjectConfig
 };

package/src/utils/backgroundJobPoller.js

@@ -58,7 +58,7 @@ async function pollForCompletion(http, endpoint, jobNumber, options = {}) {
   let lastProgress = -1;
   let pollCount = 0;
 
-  while (status === 'running' || status === 'scheduled') {
+  while (status === 'running' || status === 'scheduled' || status === 'STARTING') {
     // Wait before polling (except first time)
     if (pollCount > 0) {
       await sleep(pollInterval);

package/src/utils/version-check.js

@@ -3,8 +3,30 @@
  */
 const pathModule = require('path');
 const fs = require('fs');
+const os = require('os');
 const https = require('https');
 
+/**
+ * Get cache directory for abapgit-agent
+ * Follows OS-specific conventions:
+ * - Windows: %LOCALAPPDATA%\abapgit-agent\cache
+ * - Linux/macOS: ~/.cache/abapgit-agent (respects XDG_CACHE_HOME)
+ * @returns {string} Cache directory path
+ */
+function getCacheDir() {
+  const homeDir = os.homedir();
+
+  // Windows: %LOCALAPPDATA%\abapgit-agent\cache
+  if (process.platform === 'win32') {
+    const localAppData = process.env.LOCALAPPDATA || pathModule.join(homeDir, 'AppData', 'Local');
+    return pathModule.join(localAppData, 'abapgit-agent', 'cache');
+  }
+
+  // Linux/macOS: respect XDG_CACHE_HOME or use ~/.cache
+  const xdgCache = process.env.XDG_CACHE_HOME || pathModule.join(homeDir, '.cache');
+  return pathModule.join(xdgCache, 'abapgit-agent');
+}
+
 /**
  * Get CLI version from package.json
  * @returns {string} CLI version or '1.0.0' as default
@@ -74,7 +96,166 @@ async function checkCompatibility(config) {
   }
 }
 
+/**
+ * Get configured npm registry URL
+ * Respects user's npm config (e.g., corporate mirrors, regional mirrors)
+ * @returns {string} Registry URL
+ */
+function getNpmRegistry() {
+  try {
+    const { execSync } = require('child_process');
+    const registry = execSync('npm config get registry', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'ignore'] // Suppress stderr
+    }).trim();
+
+    // Validate registry URL
+    if (registry && registry.startsWith('http')) {
+      return registry;
+    }
+  } catch (e) {
+    // Fall back to default if npm config fails
+  }
+
+  // Default npm registry
+  return 'https://registry.npmjs.org/';
+}
+
+/**
+ * Get latest version from npm registry
+ * Respects user's configured npm registry (mirrors, corporate proxies, etc.)
+ * @returns {Promise<string|null>} Latest version or null on error
+ */
+async function getLatestNpmVersion() {
+  return new Promise((resolve) => {
+    try {
+      const registry = getNpmRegistry();
+      // Ensure registry ends with /
+      const baseUrl = registry.endsWith('/') ? registry : registry + '/';
+      const url = `${baseUrl}abapgit-agent/latest`;
+
+      https.get(url, (res) => {
+        let body = '';
+        res.on('data', chunk => body += chunk);
+        res.on('end', () => {
+          try {
+            const data = JSON.parse(body);
+            resolve(data.version || null);
+          } catch (e) {
+            resolve(null);
+          }
+        });
+      }).on('error', () => resolve(null));
+    } catch (e) {
+      resolve(null);
+    }
+  });
+}
+
+/**
+ * Compare two semver versions
+ * @param {string} a - Version A (e.g., "1.9.0")
+ * @param {string} b - Version B (e.g., "1.8.6")
+ * @returns {number} 1 if a > b, -1 if a < b, 0 if equal
+ */
+function compareVersions(a, b) {
+  const aParts = a.split('.').map(Number);
+  const bParts = b.split('.').map(Number);
+
+  for (let i = 0; i < 3; i++) {
+    if (aParts[i] > bParts[i]) return 1;
+    if (aParts[i] < bParts[i]) return -1;
+  }
+  return 0;
+}
+
+/**
+ * Check for new version availability with daily caching
+ * Cache file location (OS-specific):
+ * - Linux/macOS: ~/.cache/abapgit-agent/version-check.json
+ * - Windows: %LOCALAPPDATA%\abapgit-agent\cache\version-check.json
+ * Format: { lastCheck: timestamp, latestVersion: "1.9.0" }
+ * @returns {Promise<object>} { hasNewVersion, latestVersion, currentVersion }
+ */
+async function checkForNewVersion() {
+  const cliVersion = getCliVersion();
+  const cacheFile = pathModule.join(getCacheDir(), 'version-check.json');
+  const now = Date.now();
+  const ONE_DAY = 24 * 60 * 60 * 1000;
+
+  // Read cache if exists and less than 24 hours old
+  if (fs.existsSync(cacheFile)) {
+    try {
+      const cache = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+      if (now - cache.lastCheck < ONE_DAY && cache.latestVersion) {
+        // Use cached result
+        return {
+          hasNewVersion: compareVersions(cache.latestVersion, cliVersion) > 0,
+          latestVersion: cache.latestVersion,
+          currentVersion: cliVersion
+        };
+      }
+    } catch (e) {
+      // Invalid cache, continue to fetch
+    }
+  }
+
+  // Fetch latest version from npm
+  const latestVersion = await getLatestNpmVersion();
+
+  if (latestVersion) {
+    // Write cache
+    try {
+      const cacheDir = pathModule.dirname(cacheFile);
+      if (!fs.existsSync(cacheDir)) {
+        fs.mkdirSync(cacheDir, { recursive: true });
+      }
+      fs.writeFileSync(cacheFile, JSON.stringify({
+        lastCheck: now,
+        latestVersion: latestVersion
+      }));
+    } catch (e) {
+      // Ignore cache write errors
+    }
+
+    return {
+      hasNewVersion: compareVersions(latestVersion, cliVersion) > 0,
+      latestVersion: latestVersion,
+      currentVersion: cliVersion
+    };
+  }
+
+  // Failed to fetch, return no update
+  return {
+    hasNewVersion: false,
+    latestVersion: null,
+    currentVersion: cliVersion
+  };
+}
+
+/**
+ * Show new version reminder at end of command output
+ * Non-blocking, silent on error
+ */
+async function showNewVersionReminder() {
+  try {
+    const { hasNewVersion, latestVersion, currentVersion } = await checkForNewVersion();
+
+    if (hasNewVersion) {
+      console.log('');
+      console.log(`💡 New version available: ${latestVersion} (current: ${currentVersion})`);
+      console.log(`   Run: abapgit-agent upgrade`);
+    }
+  } catch (e) {
+    // Silent - don't interrupt user's workflow
+  }
+}
+
 module.exports = {
   getCliVersion,
-  checkCompatibility
+  checkCompatibility,
+  getLatestNpmVersion,
+  compareVersions,
+  checkForNewVersion,
+  showNewVersionReminder
 };