abapgit-agent 1.18.2 → 1.19.1

package/abap/guidelines/abapgit-xml-only.md

@@ -6,9 +6,9 @@ parent: ABAP Coding Guidelines
 grand_parent: ABAP Development
 ---
 
-# abapGit XML Metadata — XML-Only Objects (TABL, STRU, DTEL, TTYP, DOMA, MSAG)
+# abapGit XML Metadata — XML-Only Objects (TABL, STRU, DTEL, TTYP, DOMA, MSAG, SUSO)
 
-XML templates for ABAP Dictionary objects that have no `.abap` source file — TABL, STRU, DTEL, TTYP, DOMA, and message classes (MSAG).
+XML templates for ABAP Dictionary objects that have no `.abap` source file — TABL, STRU, DTEL, TTYP, DOMA, message classes (MSAG), and authorization objects (SUSO).
 
 > **CRITICAL: Always write XML files with a UTF-8 BOM (`\ufeff`) as the very first character**, before `<?xml ...`.
 > Without the BOM, abapGit shows the object as **"M" (modified)** after every pull.
@@ -19,7 +19,7 @@ XML templates for ABAP Dictionary objects that have no `.abap` source file — T
 > **For CLAS, INTF, PROG, DDLS, DCLS, FUGR** (have source files): see `abapgit-agent ref --topic abapgit`
 > **For DDLS, DCLS** (CDS — have source files): also see `abapgit-agent ref --topic abapgit`
 
-**Searchable keywords**: table xml, structure xml, data element xml, table type xml, domain xml, message class xml, tabl, stru, dtel, ttyp, doma, msag, dictionary
+**Searchable keywords**: table xml, structure xml, data element xml, table type xml, domain xml, message class xml, tabl, stru, dtel, ttyp, doma, msag, suso, authorization object, dictionary
 
 ---
 
@@ -451,3 +451,63 @@ abapGit uses the view `DD01V` as the root element (not `DD01L`). The serializer
 - `T100/TEXT`: Message text — use `&1`–`&4` for placeholders (serialized as `&amp;1`–`&amp;4` in XML)
 
 **Note**: The `<T100>` wrapper contains repeated `<T100>` child elements — one per message.
+
+---
+
+### Authorization Object (SUSO)
+
+**Filename**: `src/zmy_suso.suso.xml`
+
+> Pull with: `pull --files src/zmy_suso.suso.xml`
+>
+> View with: `view --objects ZMY_SUSO --type SUSO`
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<abapGit version="v1.0.0" serializer="LCL_OBJECT_SUSO" serializer_version="v1.0.0">
+ <asx:abap xmlns:asx="http://www.sap.com/abapxml" version="1.0">
+  <asx:values>
+   <TOBJ>
+    <OBJCT>ZMY_SUSO</OBJCT>
+    <FIEL1>ACTVT</FIEL1>
+    <FIEL2>ZMY_FIELD</FIEL2>
+    <OCLSS>ZMY</OCLSS>
+   </TOBJ>
+   <TOBJT>
+    <LANGU>E</LANGU>
+    <OBJECT>ZMY_SUSO</OBJECT>
+    <TTEXT>My authorization object description</TTEXT>
+   </TOBJT>
+   <TOBJVORFLG>
+    <OBJCT>ZMY_SUSO</OBJCT>
+   </TOBJVORFLG>
+   <TACTZ>
+    <TACTZ>
+     <BROBJ>ZMY_SUSO</BROBJ>
+     <ACTVT>01</ACTVT>
+    </TACTZ>
+    <TACTZ>
+     <BROBJ>ZMY_SUSO</BROBJ>
+     <ACTVT>02</ACTVT>
+    </TACTZ>
+    <TACTZ>
+     <BROBJ>ZMY_SUSO</BROBJ>
+     <ACTVT>03</ACTVT>
+    </TACTZ>
+   </TACTZ>
+  </asx:values>
+ </asx:abap>
+</abapGit>
+```
+
+**Key Fields**:
+- `TOBJ/OBJCT`: Authorization object name — same as the filename stem
+- `TOBJ/FIEL1`–`FIEL0`: Up to 10 authorization fields (from SU20) that make up this object
+- `TOBJ/OCLSS`: Object class (4 chars) — groups related authorization objects (e.g. `AAAB`, `BC_A`)
+- `TOBJT/TTEXT`: Description text
+- `TOBJVORFLG`: Flags record — include with just `OBJCT` when no flags are set
+- `TACTZ`: Allowed activity values — one `<TACTZ>` entry per permitted `ACTVT` value
+
+**Note**: Authorization objects (SUSO) are the SU21 objects that group authorization fields (AUTH/SU20)
+together. An object like `AUD_SCOPEM` uses fields `ACTVT`, `BO_SERVICE`, and `AUD_GROUP`.
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abapgit-agent",
-  "version": "1.18.2",
+  "version": "1.19.1",
   "description": "ABAP Git Agent - Pull and activate ABAP code via abapGit from any git repository",
   "files": [
     "bin/",
@@ -54,6 +54,7 @@
     "test:pull": "node tests/run-all.js --pull",
     "test:full-pull": "node tests/run-all.js --full-pull",
     "test:conflict": "node tests/run-all.js --conflict",
+    "test:async-pull": "node tests/run-all.js --async-pull",
     "pull": "node bin/abapgit-agent",
     "release": "node scripts/release.js",
     "unrelease": "node scripts/unrelease.js"

package/src/commands/inspect.js

@@ -24,15 +24,17 @@ function escapeXml(str) {
  * 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 name="Inspect / Syntax check" classname="ZCL_MY_CLASS"/>   ← clean
+ *       <testcase name="Inspect / CL_CI_TEST_EXCEPTION/UNHANDLED_01"         ← finding
+ *                classname="ZCL_MY_CLASS">
+ *         <failure type="SyntaxError" message="...">method/line/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).
+ * One testsuite per object. Each error/warning becomes its own testcase named
+ * after the SCI check rule (check_class/check_code) so Jenkins shows exactly
+ * which rule fired. Clean objects get a single passing testcase.
  */
 function buildInspectJUnit(results) {
   const suites = results.map(res => {
@@ -42,49 +44,56 @@ function buildInspectJUnit(results) {
     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 = [];
 
+    const inspectClass = `${escapeXml(objectName)}.Inspect`;
+
     if (errorCount === 0 && warnCount === 0) {
-      testcases.push(`    <testcase name="Syntax check" classname="${escapeXml(objectName)}"/>`);
+      testcases.push(`    <testcase name="Syntax check" classname="${inspectClass}"/>`);
     }
 
     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 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 sobjname   = err.SOBJNAME    || err.sobjname    || '';
+      const checkClass = err.CHECK_CLASS || err.check_class || '';
+      const checkCode  = err.CHECK_CODE  || err.check_code  || '';
       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}`;
+      const checkId  = checkClass && checkCode ? `${checkClass}/${checkCode}` : null;
+      const caseName = checkId ? checkId : (methodName ? `${methodName} line ${line}` : `Line ${line}`);
       testcases.push(
-        `    <testcase name="${escapeXml(caseName)}" classname="${escapeXml(objectName)}">\n` +
+        `    <testcase name="${escapeXml(caseName)}" classname="${inspectClass}">\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 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 sobjname   = warn.SOBJNAME    || warn.sobjname    || '';
+      const checkClass = warn.CHECK_CLASS || warn.check_class || '';
+      const checkCode  = warn.CHECK_CODE  || warn.check_code  || '';
       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)`;
+      const checkId  = checkClass && checkCode ? `${checkClass}/${checkCode}` : null;
+      const caseName = checkId ? checkId : (methodName ? `${methodName} line ${line}` : `Line ${line}`);
       testcases.push(
-        `    <testcase name="${escapeXml(caseName)}" classname="${escapeXml(objectName)}">\n` +
+        `    <testcase name="${escapeXml(caseName)}" classname="${inspectClass}">\n` +
         `      <failure type="Warning" message="${escapeXml(text)}">${escapeXml(detail)}</failure>\n` +
         `    </testcase>`
       );
@@ -107,8 +116,10 @@ function buildInspectJUnit(results) {
 }
 
 /**
- * Inspect all files in one request
+ * Inspect a single batch of files in one request (max CHUNK_SIZE files)
  */
+const CHUNK_SIZE = 10;
+
 async function inspectAllFiles(files, csrfToken, config, variant, http, verbose = false) {
   // Convert files to uppercase names
   const fileNames = files.map(f => {
@@ -152,6 +163,66 @@ async function inspectAllFiles(files, csrfToken, config, variant, http, verbose
   }
 }
 
+/**
+ * Apply inspect.suppress rules to a single result — downgrade matching errors/warnings to infos.
+ */
+function applySuppressRules(result, suppressRules) {
+  if (!suppressRules || suppressRules.length === 0) return;
+  const objName = (result.OBJECT_NAME || result.object_name || '').toUpperCase();
+  for (const rule of suppressRules) {
+    const objPattern = new RegExp('^' + (rule.object || '*').toUpperCase().replace(/\*/g, '.*') + '$');
+    if (!objPattern.test(objName)) continue;
+    const msgPattern = new RegExp((rule.message || '*').replace(/\*/g, '.*'), 'i');
+
+    const errors = result.ERRORS || result.errors || [];
+    const kept = [];
+    for (const err of errors) {
+      const text = err.TEXT || err.text || '';
+      if (msgPattern.test(text)) {
+        const infos = result.INFOS || result.infos || [];
+        infos.push({ ...err, MESSAGE: `[suppressed] ${text}`, message: `[suppressed] ${text}` });
+        if (result.INFOS !== undefined) result.INFOS = infos; else result.infos = infos;
+        const ec = result.ERROR_COUNT !== undefined ? 'ERROR_COUNT' : 'error_count';
+        result[ec] = Math.max(0, (result[ec] || 0) - 1);
+      } else {
+        kept.push(err);
+      }
+    }
+    if (result.ERRORS !== undefined) result.ERRORS = kept; else result.errors = kept;
+
+    const warnings = result.WARNINGS || result.warnings || [];
+    const keptW = [];
+    for (const warn of warnings) {
+      const text = warn.MESSAGE || warn.message || '';
+      if (msgPattern.test(text)) {
+        const infos = result.INFOS || result.infos || [];
+        infos.push({ ...warn, MESSAGE: `[suppressed] ${text}`, message: `[suppressed] ${text}` });
+        if (result.INFOS !== undefined) result.INFOS = infos; else result.infos = infos;
+      } else {
+        keptW.push(warn);
+      }
+    }
+    if (result.WARNINGS !== undefined) result.WARNINGS = keptW; else result.warnings = keptW;
+  }
+}
+
+/**
+ * Split files into chunks and inspect each sequentially, combining results.
+ * Calls onChunkResult(result) for each object result as chunks complete.
+ */
+async function inspectInChunks(files, csrfToken, config, variant, http, verbose = false, onChunkResult = null) {
+  const results = [];
+  for (let i = 0; i < files.length; i += CHUNK_SIZE) {
+    const chunk = files.slice(i, i + CHUNK_SIZE);
+    const chunkResults = await inspectAllFiles(chunk, csrfToken, config, variant, http, verbose);
+    for (const result of chunkResults) {
+      results.push(result);
+      if (onChunkResult) onChunkResult(result);
+    }
+  }
+  return results;
+}
+
 /**
  * Process a single inspect result
  */
@@ -181,6 +252,8 @@ async function processInspectResult(res) {
       const text = err.TEXT || err.text || 'Unknown error';
       const methodName = err.METHOD_NAME || err.method_name;
       const sobjname = err.SOBJNAME || err.sobjname;
+      const checkClass = err.CHECK_CLASS || err.check_class || '';
+      const checkCode  = err.CHECK_CODE  || err.check_code  || '';
 
       if (methodName) {
         console.log(`  Method: ${methodName}`);
@@ -190,6 +263,10 @@ async function processInspectResult(res) {
         console.log(`    Include: ${sobjname}`);
       }
       console.log(`    ${text}`);
+      if (checkCode) {
+        console.log(`    [${checkClass}/${checkCode}]`);
+        console.log(`    → abapgit-agent inspect --doc ${checkClass}/${checkCode}`);
+      }
       console.log('');
     }
 
@@ -202,6 +279,8 @@ async function processInspectResult(res) {
         const text = warn.MESSAGE || warn.message || 'Unknown warning';
         const methodName = warn.METHOD_NAME || warn.method_name;
         const sobjname = warn.SOBJNAME || warn.sobjname;
+        const checkClass = warn.CHECK_CLASS || warn.check_class || '';
+        const checkCode  = warn.CHECK_CODE  || warn.check_code  || '';
 
         if (methodName) {
           console.log(`  Method: ${methodName}`);
@@ -211,6 +290,10 @@ async function processInspectResult(res) {
           console.log(`    Include: ${sobjname}`);
         }
         console.log(`    ${text}`);
+        if (checkCode) {
+          console.log(`    [${checkClass}/${checkCode}]`);
+          console.log(`    → abapgit-agent inspect --doc ${checkClass}/${checkCode}`);
+        }
       }
     }
 
@@ -223,6 +306,8 @@ async function processInspectResult(res) {
         const text = info.MESSAGE || info.message || 'Unknown info';
         const methodName = info.METHOD_NAME || info.method_name;
         const sobjname = info.SOBJNAME || info.sobjname;
+        const checkClass = info.CHECK_CLASS || info.check_class || '';
+        const checkCode  = info.CHECK_CODE  || info.check_code  || '';
 
         if (methodName) {
           console.log(`  Method: ${methodName}`);
@@ -232,6 +317,10 @@ async function processInspectResult(res) {
           console.log(`    Include: ${sobjname}`);
         }
         console.log(`    ${text}`);
+        if (checkCode) {
+          console.log(`    [${checkClass}/${checkCode}]`);
+          console.log(`    → abapgit-agent inspect --doc ${checkClass}/${checkCode}`);
+        }
       }
     }
   } else if (success === true || success === 'X') {
@@ -254,25 +343,78 @@ module.exports = {
       console.log(`
 Usage:
   abapgit-agent inspect --files <file1>,<file2>,... [--variant <check-variant>] [--junit-output <file>] [--json]
+  abapgit-agent inspect --doc <check_class>/<check_code>
 
 Description:
   Run SAP Code Inspector checks on activated ABAP objects. Requires the objects
   to be already active in the ABAP system (run pull first).
 
+  Use --doc to fetch the SAP documentation for a specific check finding.
+  The check class and code are shown in brackets after each finding, e.g.:
+    [CL_CI_TEST_OMIT_BRACKETS/OMIT_01]
+
 Parameters:
-  --files <file1,...>       Comma-separated ABAP source files (required).
+  --files <file1,...>       Comma-separated ABAP source files (required for inspection).
   --variant <variant>       Code Inspector variant (default: system default).
   --junit-output <file>     Write results as JUnit XML to this file.
   --json                    Output as JSON.
+  --doc <class>/<code>      Fetch documentation for a check finding.
 
 Examples:
   abapgit-agent inspect --files src/zcl_my_class.clas.abap
   abapgit-agent inspect --files src/zcl_my_class.clas.abap --variant ALL_CHECKS
   abapgit-agent inspect --files src/zcl_my_class.clas.abap --junit-output reports/inspect.xml
+  abapgit-agent inspect --doc CL_CI_TEST_OMIT_BRACKETS/OMIT_01
 `);
       return;
     }
 
+    // --doc mode: fetch documentation for a check finding
+    const docArgIndex = args.indexOf('--doc');
+    if (docArgIndex !== -1) {
+      const docArg = args[docArgIndex + 1];
+      if (!docArg || !docArg.includes('/')) {
+        console.error('Error: --doc requires <check_class>/<check_code>');
+        console.error('Example: abapgit-agent inspect --doc CL_CI_TEST_OMIT_BRACKETS/OMIT_01');
+        process.exit(1);
+      }
+      const slashIdx = docArg.indexOf('/');
+      const checkClass = docArg.slice(0, slashIdx);
+      const checkCode  = docArg.slice(slashIdx + 1);
+
+      const config = loadConfig();
+      const http = new AbapHttp(config);
+      const csrfToken = await http.fetchCsrfToken();
+
+      try {
+        const result = await http.post('/sap/bc/z_abapgit_agent/insp_doc', {
+          check_class: checkClass,
+          check_code:  checkCode
+        }, { csrfToken });
+
+        const title = result.TITLE || result.title || '';
+        let   text  = result.TEXT  || result.text  || '';
+
+        // Strip ITF inline tags (<AB>, <EX>, </>, <DS:...>, etc.), HTML tags, and ITF placeholders (&...&)
+        text = text
+          .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+          .replace(/<[^>]+>/g, '')
+          .replace(/&[A-Z_]+&/g, '')
+          .replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&')
+          .replace(/&nbsp;/g, ' ').replace(/&#160;/g, ' ')
+          .replace(/\n{3,}/g, '\n\n')
+          .trim();
+
+        if (title) console.log(`\n${title}\n${'─'.repeat(Math.min(title.length, 60))}`);
+        console.log(`\n${text || 'No documentation available.'}\n`);
+      } catch (error) {
+        const { printHttpError } = require('../utils/format-error');
+        printHttpError(error, { verbose: args.includes('--verbose') });
+        process.exit(1);
+      }
+      return;
+    }
+
     const jsonOutput = args.includes('--json');
     const verbose = args.includes('--verbose');
     const filesArgIndex = args.indexOf('--files');
@@ -285,7 +427,7 @@ Examples:
       process.exit(1);
     }
 
-    let filesSyntaxCheck = args[filesArgIndex + 1].split(',').map(f => f.trim());
+    let filesSyntaxCheck = [...new Set(args[filesArgIndex + 1].split(',').map(f => f.trim()))];
 
     // Parse optional --variant parameter; fall back to project config
     const variantArgIndex = args.indexOf('--variant');
@@ -338,51 +480,23 @@ Examples:
     const http = new AbapHttp(config);
     const csrfToken = await http.fetchCsrfToken();
 
-    // Send all files in one request
-    const results = await inspectAllFiles(filesSyntaxCheck, csrfToken, config, variant, http, verbose);
-
-    // Apply inspect.suppress rules — downgrade matching errors/warnings to infos
     const suppressRules = inspectConfig.suppress || [];
-    if (suppressRules.length > 0) {
+    let hasErrors = false;
+
+    // Stream results: apply suppress and print each object as its chunk completes
+    const onChunkResult = jsonOutput ? null : async (result) => {
+      applySuppressRules(result, suppressRules);
+      await processInspectResult(result);
+      const errorCount = result.ERROR_COUNT !== undefined ? result.ERROR_COUNT : (result.error_count || 0);
+      if (errorCount > 0) hasErrors = true;
+    };
+
+    const results = await inspectInChunks(filesSyntaxCheck, csrfToken, config, variant, http, verbose, onChunkResult);
+
+    // For JSON mode, apply suppress rules now (they were skipped during streaming)
+    if (jsonOutput) {
       for (const result of results) {
-        const objName = (result.OBJECT_NAME || result.object_name || '').toUpperCase();
-        for (const rule of suppressRules) {
-          const objPattern = new RegExp('^' + (rule.object || '*').toUpperCase().replace(/\*/g, '.*') + '$');
-          if (!objPattern.test(objName)) continue;
-          const msgPattern = new RegExp((rule.message || '*').replace(/\*/g, '.*'), 'i');
-
-          // Downgrade matching errors → infos
-          const errors = result.ERRORS || result.errors || [];
-          const kept = [];
-          for (const err of errors) {
-            const text = err.TEXT || err.text || '';
-            if (msgPattern.test(text)) {
-              const infos = result.INFOS || result.infos || [];
-              infos.push({ ...err, MESSAGE: `[suppressed] ${text}`, message: `[suppressed] ${text}` });
-              if (result.INFOS !== undefined) result.INFOS = infos; else result.infos = infos;
-              const ec = result.ERROR_COUNT !== undefined ? 'ERROR_COUNT' : 'error_count';
-              result[ec] = Math.max(0, (result[ec] || 0) - 1);
-            } else {
-              kept.push(err);
-            }
-          }
-          if (result.ERRORS !== undefined) result.ERRORS = kept; else result.errors = kept;
-
-          // Downgrade matching warnings → infos
-          const warnings = result.WARNINGS || result.warnings || [];
-          const keptW = [];
-          for (const warn of warnings) {
-            const text = warn.MESSAGE || warn.message || '';
-            if (msgPattern.test(text)) {
-              const infos = result.INFOS || result.infos || [];
-              infos.push({ ...warn, MESSAGE: `[suppressed] ${text}`, message: `[suppressed] ${text}` });
-              if (result.INFOS !== undefined) result.INFOS = infos; else result.infos = infos;
-            } else {
-              keptW.push(warn);
-            }
-          }
-          if (result.WARNINGS !== undefined) result.WARNINGS = keptW; else result.warnings = keptW;
-        }
+        applySuppressRules(result, suppressRules);
       }
     }
 
@@ -408,14 +522,6 @@ Examples:
       return;
     }
 
-    // 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

@@ -3,6 +3,7 @@
  */
 
 const { printHttpError } = require('../utils/format-error');
+const { pollForCompletion, displayProgress } = require('../utils/backgroundJobPoller');
 const fs = require('fs');
 const pathModule = require('path');
 const { execSync } = require('child_process');
@@ -295,7 +296,49 @@ Examples:
         data.transport_request = transportRequest;
       }
 
-      const result = await http.post('/sap/bc/z_abapgit_agent/pull', data, { csrfToken });
+      const rawResult = await http.post('/sap/bc/z_abapgit_agent/pull', data, { csrfToken });
+
+      // --- Async pull: ABAP returned 202 (job scheduled for >10 files) ---
+      const jobStatus = rawResult.STATUS || rawResult.status;
+      const jobNumber = rawResult.JOB_NUMBER || rawResult.jobNumber;
+      let result = rawResult;
+
+      if ((jobStatus === 'scheduled' || jobStatus === 'accepted') && jobNumber) {
+        const fileCount = (data.files || []).length;
+        if (!jsonOutput) {
+          console.log(`  Activating ${fileCount} file(s) as background job...`);
+          console.log('');
+        }
+
+        const endpoint = '/sap/bc/z_abapgit_agent/pull';
+        let finalJobResult;
+        try {
+          finalJobResult = await pollForCompletion(http, endpoint, jobNumber, {
+            pollInterval: 2000,
+            maxAttempts: 300,
+            onProgress: jsonOutput ? () => {} : (progress, message) => {
+              displayProgress(progress, message);
+            }
+          });
+        } finally {
+          if (!jsonOutput) process.stdout.write('\n');
+        }
+
+        if (!finalJobResult || finalJobResult.status === 'error') {
+          const errMsg = (finalJobResult && (finalJobResult.result || finalJobResult.message)) || 'Pull background job failed';
+          const err = new Error(errMsg);
+          err._isPullError = true;
+          throw err;
+        }
+
+        // Parse the result JSON string from the completed job
+        const resultStr = finalJobResult.result || finalJobResult.RESULT;
+        try {
+          result = typeof resultStr === 'string' ? JSON.parse(resultStr) : resultStr;
+        } catch (e) {
+          result = { success: '', message: 'Failed to parse pull job result' };
+        }
+      }
 
       // Detect missing .abapgit.xml — without it abapGit's stored starting_folder
       // may not match the actual source folder, causing pull to silently return ACTIVATED_COUNT=0

package/src/commands/unit.js

@@ -48,48 +48,84 @@ function buildRunConfigXml(adtUri, coverage) {
  * Returns:
  *   {
  *     className,
- *     methods: [{ name, passed, kind?, title?, detail? }],
+ *     methods: [{
+ *       name, testClassName, passed, executionTime,
+ *       kind?, title?, details?: string[], stack?: [{name, uri}]
+ *     }],
  *     coverageStats: { totalLines, coveredLines, coverageRate } | null
  *   }
  */
 function parseRunResult(xml, className) {
   const methods = [];
 
-  // Split on <testMethod — each block is one method
-  const methodBlocks = xml.split(/<testMethod\s/);
-  for (let i = 1; i < methodBlocks.length; i++) {
-    const block = methodBlocks[i];
+  // Split on <testClass blocks to capture test class name per method
+  const testClassBlocks = xml.split(/<testClass\s/);
+  for (let ci = 1; ci < testClassBlocks.length; ci++) {
+    const classBlock = testClassBlocks[ci];
 
-    const nameMatch = block.match(/adtcore:name="([^"]*)"/);
-    if (!nameMatch) continue;
-    const name = nameMatch[1];
+    const classNameMatch = classBlock.match(/adtcore:name="([^"]*)"/);
+    const testClassName = classNameMatch ? classNameMatch[1] : className;
 
-    // Find the <alerts> section — content between <alerts> and </alerts>
-    const alertsMatch = block.match(/<alerts>([\s\S]*?)<\/alerts>/);
-    const alertsContent = alertsMatch ? alertsMatch[1].trim() : '';
+    // Split methods within this test class block
+    const methodBlocks = classBlock.split(/<testMethod\s/);
+    for (let i = 1; i < methodBlocks.length; i++) {
+      const block = methodBlocks[i];
 
-    if (!alertsContent || alertsContent === '<alerts/>') {
-      methods.push({ name, passed: true });
-      continue;
-    }
+      const nameMatch = block.match(/adtcore:name="([^"]*)"/);
+      if (!nameMatch) continue;
+      const name = nameMatch[1];
+
+      const execTimeMatch = block.match(/executionTime="([^"]*)"/);
+      const executionTime = execTimeMatch ? parseFloat(execTimeMatch[1]) : 0;
 
-    // Extract alert kind
-    const kindMatch = block.match(/<alert\s[^>]*kind="([^"]*)"/);
-    const kind = kindMatch ? kindMatch[1] : 'failedAssertion';
+      // Find the <alerts> section
+      const alertsMatch = block.match(/<alerts>([\s\S]*?)<\/alerts>/);
+      const alertsContent = alertsMatch ? alertsMatch[1].trim() : '';
 
-    // Extract title
-    const titleMatch = block.match(/<title[^>]*>([^<]*)<\/title>/);
-    const title = titleMatch ? titleMatch[1].trim() : 'Test failed';
+      if (!alertsContent || alertsContent === '<alerts/>') {
+        methods.push({ name, testClassName, passed: true, executionTime });
+        continue;
+      }
 
-    // Extract first detail text
-    const detailMatch = block.match(/<detail\s[^>]*text="([^"]*)"/);
-    const detail = detailMatch ? detailMatch[1].trim() : '';
+      // Extract alert kind
+      const kindMatch = block.match(/<alert\s[^>]*kind="([^"]*)"/);
+      const kind = kindMatch ? kindMatch[1] : 'failedAssertion';
+
+      // Extract title
+      const titleMatch = block.match(/<title[^>]*>([^<]*)<\/title>/);
+      const title = titleMatch ? titleMatch[1].trim() : 'Test failed';
+
+      // Extract all detail texts (may be multiple)
+      const details = [];
+      const detailRe = /<detail\s[^>]*text="([^"]*)"/g;
+      let dm;
+      while ((dm = detailRe.exec(block)) !== null) {
+        const t = dm[1].trim();
+        if (t) details.push(t);
+      }
 
-    methods.push({ name, passed: false, kind, title, detail });
+      // Extract stack entries: adtcore:name + adtcore:uri (contains #start=N for line)
+      const stack = [];
+      const stackRe = /<stackEntry\s([^>]*\/?>)/g;
+      let sm;
+      while ((sm = stackRe.exec(block)) !== null) {
+        const entry = sm[1];
+        const snMatch = entry.match(/adtcore:name="([^"]*)"/);
+        const suMatch = entry.match(/adtcore:uri="([^"]*)"/);
+        if (snMatch) {
+          const lineMatch = suMatch && suMatch[1].match(/#start=(\d+)/);
+          stack.push({
+            name: snMatch[1],
+            line: lineMatch ? parseInt(lineMatch[1], 10) : null,
+          });
+        }
+      }
+
+      methods.push({ name, testClassName, passed: false, executionTime, kind, title, details, stack });
+    }
   }
 
   // Parse coverage stats if present
-  // <coverage ... adtcore:lines_total="N" adtcore:lines_covered="M" adtcore:coverage_rate="R"/>
   let coverageStats = null;
   const covMatch = xml.match(/<coverage\b[^>]*>/);
   if (covMatch) {
@@ -122,6 +158,9 @@ function buildUnitJUnit(results) {
     const failedMethods = methods.filter(m => !m.passed);
     const syntheticFailures = thresholdFailure ? 1 : 0;
     const totalFailures = failedMethods.length + syntheticFailures;
+    // classname "ZCL_MY_TEST.LTCL_UNIT_TEST" groups under the same ABAP class node
+    // as "ZCL_MY_TEST.Inspect" from the inspect report — one node per ABAP class.
+    const suiteLabel = className;
 
     const lines = [];
 
@@ -134,16 +173,21 @@ function buildUnitJUnit(results) {
     }
 
     if (testCount === 0) {
-      lines.push(`    <testcase name="(no tests)" classname="${escapeXml(className)}"/>`);
+      lines.push(`    <testcase name="(no tests)" classname="${escapeXml(suiteLabel)}"/>`);
     } else {
       for (const m of methods) {
+        const timeAttr = m.executionTime != null ? ` time="${m.executionTime}"` : '';
+        // "Unit Tests / ZCL_MY_TEST.LTCL_UNIT_TEST" groups by namespace → class → local test class.
+        const testClass = m.testClassName ? `${suiteLabel}.${m.testClassName}` : suiteLabel;
         if (m.passed) {
-          lines.push(`    <testcase name="${escapeXml(m.name)}" classname="${escapeXml(className)}"/>`);
+          lines.push(`    <testcase name="${escapeXml(m.name)}" classname="${escapeXml(testClass)}"${timeAttr}/>`);
         } else {
           const msg = escapeXml(m.title || 'Test failed');
-          const body = m.detail ? escapeXml(`${m.title}\n${m.detail}`) : msg;
+          const bodyParts = [m.title || 'Test failed'];
+          if (m.details && m.details.length) bodyParts.push(...m.details);
+          const body = escapeXml(bodyParts.join('\n'));
           lines.push(
-            `    <testcase name="${escapeXml(m.name)}" classname="${escapeXml(className)}">\n` +
+            `    <testcase name="${escapeXml(m.name)}" classname="${escapeXml(testClass)}"${timeAttr}>\n` +
             `      <failure type="${escapeXml(m.kind || 'failedAssertion')}" message="${msg}">${body}</failure>\n` +
             `    </testcase>`
           );
@@ -153,14 +197,14 @@ function buildUnitJUnit(results) {
 
     if (thresholdFailure) {
       lines.push(
-        `    <testcase name="coverage_threshold" classname="${escapeXml(className)}">\n` +
+        `    <testcase name="coverage_threshold" classname="${escapeXml(suiteLabel)}">\n` +
         `      <failure type="FAILURE" message="${escapeXml(thresholdFailure)}">${escapeXml(thresholdFailure)}</failure>\n` +
         `    </testcase>`
       );
     }
 
     return (
-      `  <testsuite name="${escapeXml(className)}" ` +
+      `  <testsuite name="${escapeXml(suiteLabel)}" ` +
       `tests="${Math.max(testCount + syntheticFailures, 1)}" failures="${totalFailures}" errors="0">\n` +
       lines.join('\n') + '\n' +
       `  </testsuite>`
@@ -231,10 +275,42 @@ async function runUnitTestForFile(sourceFile, adt, coverage, jsonOutput, verbose
         console.log(`        Covered Lines: ${coveredLines}`);
       }
 
+      // Slow test summary: show methods with executionTime > 0.1s
+      const slowThreshold = 0.1;
+      const slowMethods = result.methods
+        .filter(m => m.executionTime > slowThreshold)
+        .sort((a, b) => b.executionTime - a.executionTime);
+      if (slowMethods.length > 0) {
+        const slowList = slowMethods.map(m => `${m.name} (${m.executionTime.toFixed(3)}s)`).join(', ');
+        console.log(`     ⏱  Slowest: ${slowList}`);
+      }
+
       if (failedCount > 0) {
         for (const m of result.methods.filter(m => !m.passed)) {
-          console.log(`     ✗ ${className}=>${m.name}: ${m.title || 'Test failed'}`);
+          const prefix = m.testClassName || className;
+          console.log(`\n     ✗ ${prefix}=>${m.name}`);
+          console.log(`       ${m.title || 'Test failed'}`);
+          if (m.details && m.details.length) {
+            for (const d of m.details) console.log(`       ${d}`);
+          }
+          if (m.stack && m.stack.length) {
+            for (const s of m.stack) {
+              const loc = s.line != null ? ` (line ${s.line})` : '';
+              console.log(`         at ${s.name}${loc}`);
+            }
+          }
         }
+        console.log('');
+      }
+
+      // --verbose: per-method time table
+      if (verbose && testCount > 0) {
+        console.log(`     Method times:`);
+        for (const m of result.methods) {
+          const mark = m.passed ? '✓' : '✗';
+          console.log(`       ${mark} ${m.name.padEnd(40)} ${(m.executionTime || 0).toFixed(3)}s`);
+        }
+        console.log('');
       }
     }
 
@@ -285,6 +361,7 @@ Parameters:
   --coverage-mode <warn|fail>  Action when below threshold: warn = UNSTABLE, fail = error. Default: fail.
   --junit-output <file>        Write results as JUnit XML to this file.
   --json                       Output as JSON.
+  --verbose                    Show per-method execution times; also print raw HTTP error responses.
 
 Examples:
   abapgit-agent unit --files src/zcl_my_test.clas.testclasses.abap
@@ -368,6 +445,24 @@ Examples:
       }
     }
 
+    // Failed tests summary
+    if (!jsonOutput) {
+      const allFailed = results.flatMap(r => (r.methods || []).filter(m => !m.passed).map(m => ({ ...m, className: r.className })));
+      if (allFailed.length > 0) {
+        console.log('\nFailed Tests:');
+        console.log('─'.repeat(80));
+        for (const m of allFailed) {
+          const prefix = m.testClassName || m.className;
+          console.log(`   ✗ ${prefix}=>${m.name}`);
+          console.log(`     ${m.title || 'Test failed'}`);
+          if (m.details && m.details.length) {
+            for (const d of m.details) console.log(`     ${d}`);
+          }
+          console.log('');
+        }
+      }
+    }
+
     // JUnit output
     if (junitOutput) {
       const xml = buildUnitJUnit(results);

package/src/commands/view.js

@@ -246,7 +246,7 @@ Description:
 Parameters:
   --objects <obj1,...>  Comma-separated object names (required).
   --type <type>         Object type: CLAS, INTF, PROG, TABL, STRU, DTEL, TTYP, DOMA,
-                        DDLS, DCLS, MSAG, FUGR (auto-detected from TADIR if omitted).
+                        DDLS, DCLS, MSAG, FUGR, SUSO (auto-detected from TADIR if omitted).
   --full                Show full source including all method implementations.
   --lines               Show dual line numbers (G = global for debug set, [N] = include-local).
   --fm <name>           With --full: show only the specified function module (FUGR only).
@@ -593,6 +593,51 @@ Examples:
                 console.log(`   ${desc}`);
               }
             }
+          } else if (objType === 'SUSO' || objType === 'Authorization Object') {
+            // SUSO: property box for object class + fields, then activities list
+            const classComp = components.filter(c => String(c.FIELD || c.field || '').startsWith('OCLSS'));
+            const fieldComps = components.filter(c => String(c.FIELD || c.field || '').startsWith('FIELD_'));
+            const actvtComps = components.filter(c => String(c.FIELD || c.field || '').startsWith('ACTVT_'));
+
+            const propWidth = 16;
+            const valueWidth = 42;
+            const sep = '┌' + '─'.repeat(propWidth + 2) + '┬' + '─'.repeat(valueWidth + 2) + '┐';
+            const mid = '├' + '─'.repeat(propWidth + 2) + '┼' + '─'.repeat(valueWidth + 2) + '┤';
+            const end = '└' + '─'.repeat(propWidth + 2) + '┴' + '─'.repeat(valueWidth + 2) + '┘';
+            const buildPropRow = (property, value) =>
+              '│ ' + String(property || '').padEnd(propWidth) + ' │ ' +
+              String(value || '').substring(0, valueWidth).padEnd(valueWidth) + ' │';
+
+            console.log(`  AUTH OBJECT ${objName}:`);
+            console.log(sep);
+            console.log(buildPropRow('Property', 'Value'));
+            console.log(mid);
+
+            for (const comp of classComp) {
+              const desc = comp.DESCRIPTION || comp.description || '';
+              const colonIdx = desc.indexOf(': ');
+              const value = colonIdx !== -1 ? desc.substring(colonIdx + 2) : desc;
+              console.log(buildPropRow('Object class', value));
+            }
+
+            for (const comp of fieldComps) {
+              const desc = comp.DESCRIPTION || comp.description || '';
+              const colonIdx = desc.indexOf(': ');
+              const value = colonIdx !== -1 ? desc.substring(colonIdx + 2) : desc;
+              const idx = String(comp.FIELD || comp.field || '').replace('FIELD_', '');
+              console.log(buildPropRow(`Field ${idx}`, value));
+            }
+
+            console.log(end);
+
+            if (actvtComps.length > 0) {
+              console.log('');
+              console.log(`  Allowed activities (${actvtComps.length}):`);
+              for (const comp of actvtComps) {
+                const desc = comp.DESCRIPTION || comp.description || '';
+                console.log(`    ${desc}`);
+              }
+            }
           } else {
             // Build table display for TABL/STRU with Data Element and Description
             const colWidths = {