abapgit-agent 1.13.4 → 1.13.6

package/bin/abapgit-agent

@@ -36,6 +36,12 @@ async function main() {
 
   const commandModules = require('../src/commands/index');
 
+  // Handle --version / -v
+  if (command === '--version' || command === '-v') {
+    console.log(versionCheck.getCliVersion());
+    return;
+  }
+
   // Check if this is a modular command
   if (commandModules[command] || command === '--help' || command === '-h') {
     const cmd = command === '--help' || command === '-h' ? commandModules.help : commandModules[command];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abapgit-agent",
-  "version": "1.13.4",
+  "version": "1.13.6",
   "description": "ABAP Git Agent - Pull and activate ABAP code via abapGit from any git repository",
   "files": [
     "bin/",
@@ -29,6 +29,7 @@
     "test:cmd:pull": "node tests/run-all.js --cmd --command=pull",
     "test:sync-xml": "node tests/run-all.js --sync-xml",
     "test:xml-only": "node tests/run-all.js --xml-only",
+    "test:junit": "node tests/run-all.js --junit",
     "test:cmd:inspect": "node tests/run-all.js --cmd --command=inspect",
     "test:cmd:unit": "node tests/run-all.js --cmd --command=unit",
     "test:cmd:view": "node tests/run-all.js --cmd --command=view",

package/src/commands/help.js

@@ -9,8 +9,10 @@ module.exports = {
   requiresVersionCheck: false,
 
   async execute(args, context) {
+    const { versionCheck } = context;
+    const version = versionCheck.getCliVersion();
     console.log(`
-ABAP Git Agent
+ABAP Git Agent v${version}
 
 Usage:
   abapgit-agent <command> [options]

package/src/commands/inspect.js

@@ -3,8 +3,109 @@
  */
 
 const pathModule = require('path');
+const fs = require('fs');
 const { printHttpError } = require('../utils/format-error');
 
+/**
+ * Escape a string for safe embedding in XML text/attribute content
+ */
+function escapeXml(str) {
+  return String(str)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}
+
+/**
+ * Build JUnit XML from inspect results array.
+ *
+ * Maps to JUnit schema:
+ *   <testsuites>
+ *     <testsuite name="CLAS ZCL_MY_CLASS" tests="N" failures="F" errors="0">
+ *       <testcase name="Syntax check" classname="ZCL_MY_CLASS">
+ *         <failure type="SyntaxError" message="...">line/col/method detail</failure>
+ *       </testcase>
+ *     </testsuite>
+ *   </testsuites>
+ *
+ * One testsuite per object. Each error becomes a <failure>. Warnings become
+ * a single <failure type="Warning"> so they are visible but don't fail the build
+ * unless there are also hard errors (Jenkins distinguishes failure vs unstable).
+ */
+function buildInspectJUnit(results) {
+  const suites = results.map(res => {
+    const objectType = res.OBJECT_TYPE !== undefined ? res.OBJECT_TYPE : (res.object_type || 'UNKNOWN');
+    const objectName = res.OBJECT_NAME !== undefined ? res.OBJECT_NAME : (res.object_name || 'UNKNOWN');
+    const errors     = res.ERRORS   !== undefined ? res.ERRORS   : (res.errors   || []);
+    const warnings   = res.WARNINGS !== undefined ? res.WARNINGS : (res.warnings || []);
+    const errorCount = errors.length;
+    const warnCount  = warnings.length;
+    // One testcase per error/warning; at least one testcase for a clean object
+    const testCount  = Math.max(1, errorCount + warnCount);
+
+    const testcases = [];
+
+    if (errorCount === 0 && warnCount === 0) {
+      testcases.push(`    <testcase name="Syntax check" classname="${escapeXml(objectName)}"/>`);
+    }
+
+    for (const err of errors) {
+      const line       = err.LINE       || err.line       || '?';
+      const column     = err.COLUMN     || err.column     || '?';
+      const text       = err.TEXT       || err.text       || 'Unknown error';
+      const methodName = err.METHOD_NAME || err.method_name;
+      const sobjname   = err.SOBJNAME   || err.sobjname   || '';
+      const detail     = [
+        methodName ? `Method: ${methodName}` : null,
+        `Line ${line}, Column ${column}`,
+        sobjname ? `Include: ${sobjname}` : null,
+        text
+      ].filter(Boolean).join('\n');
+      const caseName = methodName ? `${methodName} line ${line}` : `Line ${line}`;
+      testcases.push(
+        `    <testcase name="${escapeXml(caseName)}" classname="${escapeXml(objectName)}">\n` +
+        `      <failure type="SyntaxError" message="${escapeXml(text)}">${escapeXml(detail)}</failure>\n` +
+        `    </testcase>`
+      );
+    }
+
+    for (const warn of warnings) {
+      const line       = warn.LINE       || warn.line       || '?';
+      const text       = warn.MESSAGE    || warn.message    || warn.TEXT || warn.text || 'Warning';
+      const methodName = warn.METHOD_NAME || warn.method_name;
+      const sobjname   = warn.SOBJNAME   || warn.sobjname   || '';
+      const detail     = [
+        methodName ? `Method: ${methodName}` : null,
+        `Line ${line}`,
+        sobjname ? `Include: ${sobjname}` : null,
+        text
+      ].filter(Boolean).join('\n');
+      const caseName = methodName ? `${methodName} line ${line} (warning)` : `Line ${line} (warning)`;
+      testcases.push(
+        `    <testcase name="${escapeXml(caseName)}" classname="${escapeXml(objectName)}">\n` +
+        `      <failure type="Warning" message="${escapeXml(text)}">${escapeXml(detail)}</failure>\n` +
+        `    </testcase>`
+      );
+    }
+
+    return (
+      `  <testsuite name="${escapeXml(objectType + ' ' + objectName)}" ` +
+      `tests="${testCount}" failures="${errorCount + warnCount}" errors="0">\n` +
+      testcases.join('\n') + '\n' +
+      `  </testsuite>`
+    );
+  });
+
+  return (
+    '<?xml version="1.0" encoding="UTF-8"?>\n' +
+    '<testsuites>\n' +
+    suites.join('\n') + '\n' +
+    '</testsuites>\n'
+  );
+}
+
 /**
  * Inspect all files in one request
  */
@@ -154,10 +255,10 @@ module.exports = {
     const filesArgIndex = args.indexOf('--files');
     if (filesArgIndex === -1 || filesArgIndex + 1 >= args.length) {
       console.error('Error: --files parameter required');
-      console.error('Usage: abapgit-agent inspect --files <file1>,<file2>,... [--variant <check-variant>] [--json]');
+      console.error('Usage: abapgit-agent inspect --files <file1>,<file2>,... [--variant <check-variant>] [--junit-output <file>] [--json]');
       console.error('Example: abapgit-agent inspect --files src/zcl_my_class.clas.abap');
       console.error('Example: abapgit-agent inspect --files src/zcl_my_class.clas.abap --variant ALL_CHECKS');
-      console.error('Example: abapgit-agent inspect --files src/zcl_my_class.clas.abap --json');
+      console.error('Example: abapgit-agent inspect --files src/zcl_my_class.clas.abap --junit-output reports/inspect.xml');
       process.exit(1);
     }
 
@@ -167,11 +268,18 @@ module.exports = {
     const variantArgIndex = args.indexOf('--variant');
     const variant = variantArgIndex !== -1 ? args[variantArgIndex + 1] : null;
 
+    // Parse optional --junit-output parameter
+    const junitArgIndex = args.indexOf('--junit-output');
+    const junitOutput = junitArgIndex !== -1 ? args[junitArgIndex + 1] : null;
+
     if (!jsonOutput) {
       console.log(`\n  Inspect for ${filesSyntaxCheck.length} file(s)`);
       if (variant) {
         console.log(`  Using variant: ${variant}`);
       }
+      if (junitOutput) {
+        console.log(`  JUnit output: ${junitOutput}`);
+      }
       console.log('');
     }
 
@@ -182,6 +290,22 @@ module.exports = {
     // Send all files in one request
     const results = await inspectAllFiles(filesSyntaxCheck, csrfToken, config, variant, http, verbose);
 
+    // JUnit output mode — write XML file, then continue to normal output
+    if (junitOutput) {
+      const xml = buildInspectJUnit(results);
+      const outputPath = pathModule.isAbsolute(junitOutput)
+        ? junitOutput
+        : pathModule.join(process.cwd(), junitOutput);
+      const dir = pathModule.dirname(outputPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(outputPath, xml, 'utf8');
+      if (!jsonOutput) {
+        console.log(`  JUnit report written to: ${outputPath}`);
+      }
+    }
+
     // JSON output mode
     if (jsonOutput) {
       console.log(JSON.stringify(results, null, 2));
@@ -189,8 +313,15 @@ module.exports = {
     }
 
     // Process results
+    let hasErrors = false;
     for (const result of results) {
       await processInspectResult(result);
+      const errorCount = result.ERROR_COUNT !== undefined ? result.ERROR_COUNT : (result.error_count || 0);
+      if (errorCount > 0) hasErrors = true;
+    }
+
+    if (hasErrors) {
+      process.exit(1);
     }
   }
 };

package/src/commands/pull.js

@@ -168,8 +168,13 @@ module.exports = {
         const csrfToken = await http.fetchCsrfToken();
         statusResult = await http.post('/sap/bc/z_abapgit_agent/status', { url: gitUrl }, { csrfToken });
       } catch (e) {
+        const isNetworkError = e.code && ['ENOTFOUND', 'ECONNREFUSED', 'ETIMEDOUT', 'ECONNRESET'].includes(e.code);
         console.error(`❌ Repository status check failed: ${e.message}`);
-        console.error('   Make sure the repository is registered with abapgit-agent (run "abapgit-agent create").');
+        if (isNetworkError) {
+          console.error('   Cannot reach the ABAP system. Check your network connection and the host in .abapGitAgent.');
+        } else {
+          console.error('   Make sure the repository is registered with abapgit-agent (run "abapgit-agent create").');
+        }
         process.exit(1);
       }
 

package/src/commands/unit.js

@@ -6,6 +6,92 @@ const pathModule = require('path');
 const fs = require('fs');
 const { formatHttpError } = require('../utils/format-error');
 
+/**
+ * Escape a string for safe embedding in XML text/attribute content
+ */
+function escapeXml(str) {
+  return String(str)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}
+
+/**
+ * Build JUnit XML from unit test results array.
+ *
+ * Maps to JUnit schema:
+ *   <testsuites>
+ *     <testsuite name="ZCL_MY_TEST" tests="10" failures="2" errors="0">
+ *       <testcase name="TEST_METHOD_1" classname="ZCL_MY_TEST"/>
+ *       <testcase name="TEST_METHOD_2" classname="ZCL_MY_TEST">
+ *         <failure type="FAILURE" message="...">detail</failure>
+ *       </testcase>
+ *     </testsuite>
+ *   </testsuites>
+ *
+ * One testsuite per test class file. Each failed test method becomes a <failure>.
+ * Passing methods are listed as empty <testcase> elements (Jenkins counts them).
+ */
+function buildUnitJUnit(results) {
+  const suites = results.map(res => {
+    const success      = res.SUCCESS      || res.success;
+    const testCount    = res.TEST_COUNT    || res.test_count    || 0;
+    const passedCount  = res.PASSED_COUNT  || res.passed_count  || 0;
+    const failedCount  = res.FAILED_COUNT  || res.failed_count  || 0;
+    const errors       = res.ERRORS        || res.errors        || [];
+    const className    = res._className    || 'UNKNOWN';  // injected by caller
+
+    // Build a set of failed method names for quick lookup
+    const failedMethods = new Set(
+      errors.map(e => (e.CLASS_NAME || e.class_name || '') + '=>' + (e.METHOD_NAME || e.method_name || ''))
+    );
+
+    const testcases = [];
+
+    // Emit one <testcase> per failed test
+    for (const err of errors) {
+      const errClassName  = err.CLASS_NAME  || err.class_name  || className;
+      const methodName    = err.METHOD_NAME || err.method_name || '?';
+      const errorKind     = err.ERROR_KIND  || err.error_kind  || 'FAILURE';
+      const errorText     = err.ERROR_TEXT  || err.error_text  || 'Test failed';
+      testcases.push(
+        `    <testcase name="${escapeXml(methodName)}" classname="${escapeXml(errClassName)}">\n` +
+        `      <failure type="${escapeXml(errorKind)}" message="${escapeXml(errorText)}">${escapeXml(errorText)}</failure>\n` +
+        `    </testcase>`
+      );
+    }
+
+    // Emit empty <testcase> elements for passing tests (Jenkins shows total count)
+    // We can't enumerate them individually (ABAP doesn't return passing method names),
+    // so emit one aggregate passing testcase when passedCount > 0
+    if (passedCount > 0) {
+      testcases.push(
+        `    <testcase name="(${passedCount} passing test(s))" classname="${escapeXml(className)}"/>`
+      );
+    }
+
+    if (testCount === 0) {
+      testcases.push(`    <testcase name="(no tests)" classname="${escapeXml(className)}"/>`);
+    }
+
+    return (
+      `  <testsuite name="${escapeXml(className)}" ` +
+      `tests="${Math.max(testCount, 1)}" failures="${failedCount}" errors="0">\n` +
+      testcases.join('\n') + '\n' +
+      `  </testsuite>`
+    );
+  });
+
+  return (
+    '<?xml version="1.0" encoding="UTF-8"?>\n' +
+    '<testsuites>\n' +
+    suites.join('\n') + '\n' +
+    '</testsuites>\n'
+  );
+}
+
 /**
  * Run unit test for a single file
  */
@@ -151,10 +237,10 @@ module.exports = {
     const filesArgIndex = args.indexOf('--files');
     if (filesArgIndex === -1 || filesArgIndex + 1 >= args.length) {
       console.error('Error: --files parameter required');
-      console.error('Usage: abapgit-agent unit --files <file1>,<file2>,... [--coverage] [--json]');
-      console.error('Example: abapgit-agent unit --files src/zcl_my_test.clas.abap');
-      console.error('Example: abapgit-agent unit --files src/zcl_my_test.clas.abap --coverage');
-      console.error('Example: abapgit-agent unit --files src/zcl_my_test.clas.abap --json');
+      console.error('Usage: abapgit-agent unit --files <file1>,<file2>,... [--coverage] [--junit-output <file>] [--json]');
+      console.error('Example: abapgit-agent unit --files src/zcl_my_test.clas.testclasses.abap');
+      console.error('Example: abapgit-agent unit --files src/zcl_my_test.clas.testclasses.abap --coverage');
+      console.error('Example: abapgit-agent unit --files src/zcl_my_test.clas.testclasses.abap --junit-output reports/unit.xml');
       process.exit(1);
     }
 
@@ -163,8 +249,15 @@ module.exports = {
     // Check for coverage option
     const coverage = args.includes('--coverage');
 
+    // Parse optional --junit-output parameter
+    const junitArgIndex = args.indexOf('--junit-output');
+    const junitOutput = junitArgIndex !== -1 ? args[junitArgIndex + 1] : null;
+
     if (!jsonOutput) {
       console.log(`\n  Running unit tests for ${files.length} file(s)${coverage ? ' (with coverage)' : ''}`);
+      if (junitOutput) {
+        console.log(`  JUnit output: ${junitOutput}`);
+      }
       console.log('');
     }
 
@@ -172,19 +265,42 @@ module.exports = {
     const http = new AbapHttp(config);
     const csrfToken = await http.fetchCsrfToken();
 
-    // Collect results for JSON output
+    // Collect results for JSON / JUnit output
     const results = [];
     let hasErrors = false;
 
     for (const sourceFile of files) {
       const result = await runUnitTestForFile(sourceFile, csrfToken, config, coverage, http, jsonOutput, verbose);
       if (result) {
+        // Inject class name derived from file path for JUnit builder
+        const fileName = pathModule.basename(sourceFile).toUpperCase();
+        result._className = fileName.split('.')[0];
         results.push(result);
 
-        // Check if this result contains an error
         if (result.error || result.statusCode >= 400) {
           hasErrors = true;
         }
+        // Also treat failed tests as an error for exit code
+        const failedCount = result.FAILED_COUNT || result.failed_count || 0;
+        if (failedCount > 0) {
+          hasErrors = true;
+        }
+      }
+    }
+
+    // JUnit output mode — write XML, then continue to normal output
+    if (junitOutput) {
+      const xml = buildUnitJUnit(results);
+      const outputPath = pathModule.isAbsolute(junitOutput)
+        ? junitOutput
+        : pathModule.join(process.cwd(), junitOutput);
+      const dir = pathModule.dirname(outputPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(outputPath, xml, 'utf8');
+      if (!jsonOutput) {
+        console.log(`  JUnit report written to: ${outputPath}`);
       }
     }
 

package/src/utils/version-check.js

@@ -135,7 +135,8 @@ async function getLatestNpmVersion() {
       const baseUrl = registry.endsWith('/') ? registry : registry + '/';
       const url = `${baseUrl}abapgit-agent/latest`;
 
-      https.get(url, (res) => {
+      const client = url.startsWith('http://') ? http : https;
+      client.get(url, (res) => {
         let body = '';
         res.on('data', chunk => body += chunk);
         res.on('end', () => {