abapgit-agent 1.17.8 → 1.18.0

package/src/commands/debug.js

@@ -19,8 +19,10 @@
  *   - Local state persisted in tmp so stateless CLI calls share the breakpoint list.
  *
  * Session management for AI/scripting mode (--json):
- *   attach --json spawns a background daemon (debug-daemon.js) that holds the
- *   stateful ADT HTTP connection open. step/vars/stack/terminate are thin IPC
+ *   attach --json runs the IPC socket server in-process after emitting the
+ *   session JSON line. This keeps the ADT TCP connection alive in the same
+ *   process that called attach() — SAP pins the debug session to the
+ *   originating TCP connection. step/vars/stack/terminate are thin IPC
  *   clients that connect to the daemon's Unix socket and exchange one JSON command
  *   per invocation. The daemon exits when terminate is called or after 30 min idle.
  *
@@ -30,7 +32,6 @@
 
 const net  = require('net');
 const path = require('path');
-const { spawn } = require('child_process');
 const { AdtHttp }      = require('../utils/adt-http');
 const { DebugSession } = require('../utils/debug-session');
 const debugStateModule = require('../utils/debug-state');
@@ -47,7 +48,13 @@ const _loadBpState = debugStateModule.loadBreakpointState;
 // Daemon socket path — may be absent in unit-test mocks
 const _getDaemonSocketPath = debugStateModule.getDaemonSocketPath;
 
-const ADT_CLIENT_ID = 'ABAPGIT-AGENT-CLI';
+// Allow callers to override the terminalId/ideId used for listener and
+// breakpoint registration via env var. This lets CI jobs use a unique ID
+// per run to avoid stale listeners from crashed previous runs blocking
+// the listener POST (SAP ICM returns 400 if another listener with the
+// same terminalId is still registered and DELETE is not available on the
+// system).
+const ADT_CLIENT_ID = process.env.ABAPGIT_DEBUG_TERMINAL_ID || 'ABAPGIT-AGENT-CLI';
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -632,8 +639,8 @@ async function cmdDelete(args, config, adt) {
 async function cmdAttach(args, config, adt) {
   const sessionIdOverride = val(args, '--session');
   const jsonOutput = hasFlag(args, '--json');
-  // Per-poll timeout in seconds sent to ADT (ADT blocks the POST for this long)
   const pollTimeout = parseInt(val(args, '--timeout') || '30', 10);
+  const maxListenSeconds = parseInt(val(args, '--max-listen') || '240', 10);
   // Shorter timeout used in takeover mode — keeps the connection alive but
   // lets ADT process stepContinue quickly and lets session 2 exit within
   // ~5 seconds of clearActiveSession being written.
@@ -646,8 +653,42 @@ async function cmdAttach(args, config, adt) {
     process.stderr.write('\n  Waiting for breakpoint hit... (run your ABAP program in a separate window)\n');
   }
 
+  // Fresh session for attach flow. Don't set stateful here — CSRF fetch
+  // without stateful avoids tying up a dialog WP. Stateful is added per-call
+  // by debug-session.js STATEFUL_HEADER on attach/getStack/step/vars.
+  adt.clearSession();
+  if (adt._axios) {
+    const agent = adt._axios.defaults.httpsAgent || adt._axios.defaults.httpAgent;
+    if (agent) agent.destroy();
+    if (adt._axios.defaults.httpsAgent) {
+      adt._axios.defaults.httpsAgent = new (require('https').Agent)({ rejectUnauthorized: false, keepAlive: true });
+    } else if (adt._axios.defaults.httpAgent) {
+      adt._axios.defaults.httpAgent = new (require('http').Agent)({ keepAlive: true });
+    }
+  }
   await adt.fetchCsrfToken();
 
+  // Delete any stale listener registered under our terminalId from a previous
+  // (possibly crashed) run.  A frozen ABAP work process holding a listener for
+  // the same terminalId causes SAP ICM to return HTTP 400 "Service cannot be
+  // reached" for every new listener POST.  Deleting first clears that state.
+  // Ignore errors — there may be no stale listener to delete.
+  if (!sessionIdOverride) {
+    try {
+      const delUrl = `/sap/bc/adt/debugger/listeners` +
+        `?debuggingMode=user` +
+        `&requestUser=${encodeURIComponent((config.user || '').toUpperCase())}` +
+        `&terminalId=${encodeURIComponent(ADT_CLIENT_ID)}` +
+        `&ideId=${encodeURIComponent(ADT_CLIENT_ID)}` +
+        `&checkConflict=false` +
+        `&notifyConflict=true`;
+      await adt.delete(delUrl);
+      if (jsonOutput) process.stderr.write(`[debug-attach] deleted stale listener\n`);
+    } catch (e) {
+      if (jsonOutput) process.stderr.write(`[debug-attach] delete listener (cleanup): ${e.statusCode || e.message}\n`);
+    }
+  }
+
   // Re-POST local breakpoints to refresh them on the server before listening.
   // Breakpoints expire when the SAP session or work process is restarted.
   // This ensures they are active regardless of when they were originally set.
@@ -672,6 +713,7 @@ async function cmdAttach(args, config, adt) {
   }
   let sessionId = sessionIdOverride;
   let positionResult = null;
+  let session = null;
 
   if (!sessionId) {
     // ADT listeners: POST long-polls until a breakpoint is hit (or timeout).
@@ -683,9 +725,9 @@ async function cmdAttach(args, config, adt) {
       `&terminalId=${encodeURIComponent(listenTerminalId)}` +
       `&ideId=${encodeURIComponent(listenTerminalId)}`;
 
-    const MAX_POLLS = Math.ceil(240 / pollTimeout); // up to 4 minutes total
+    const MAX_POLLS = Math.ceil(maxListenSeconds / pollTimeout);
     // In takeover mode we switch to takeoverPollTimeout — recalculate the limit then.
-    const MAX_TAKEOVER_POLLS = Math.ceil(240 / takeoverPollTimeout);
+    const MAX_TAKEOVER_POLLS = Math.ceil(maxListenSeconds / takeoverPollTimeout);
     let dots = 0;
     const attachStartedAt = Date.now(); // used to detect if another session takes over
     let takenOver = false;
@@ -723,6 +765,12 @@ async function cmdAttach(args, config, adt) {
           await new Promise(r => setTimeout(r, 2000));
           continue;
         }
+        if (err && err.statusCode === 400 &&
+            err.body && err.body.includes('Service cannot be reached')) {
+          if (jsonOutput) process.stderr.write(`[debug-attach] listener POST returned 400 (Service cannot be reached), retrying in 5s...\n`);
+          await new Promise(r => setTimeout(r, 5000));
+          continue;
+        }
         if (err && err.statusCode === 404) {
           console.error(
             '\n  Debug session commands require ADT Debugger service (listeners).' +
@@ -742,6 +790,7 @@ async function cmdAttach(args, config, adt) {
         const debuggeeIdMatch = resp.body.match(/<DEBUGGEE_ID>([^<]+)<\/DEBUGGEE_ID>/i) ||
                                 resp.body.match(/DEBUGGEE_ID="([^"]+)"/i);
         sessionId = debuggeeIdMatch ? debuggeeIdMatch[1].trim() : null;
+        if (jsonOutput && sessionId) process.stderr.write(`[debug-attach] listener returned debuggeeId=${sessionId}\n`);
 
         if (!sessionId) {
           // Fallback: some ADT versions put session info in different attributes
@@ -773,6 +822,34 @@ async function cmdAttach(args, config, adt) {
           }
           continue;
         }
+
+        // Attach to the WP and verify it's alive before committing.
+        // In --json mode: if the WP is a stale session from a previous run,
+        // attach() may succeed but getPosition() returns 400. When that happens,
+        // reset the SAP session fully and continue listening for a fresh BP hit.
+        {
+          if (!jsonOutput) process.stderr.write('\n  Attaching to debug session...\n');
+          const candidateSession = new DebugSession(adt, sessionId);
+          try {
+            await candidateSession.attach(sessionId, (config.user || '').toUpperCase());
+          } catch (e) {
+            if (jsonOutput) {
+              process.stderr.write(`[debug-attach] attach() failed: ${e.message || e} — resetting session\n`);
+              adt.clearSession();
+              await adt.fetchCsrfToken();
+              sessionId = null;
+              continue;
+            }
+            printHttpError(e, { prefix: '  Error during attach' });
+            if (e.body) console.error('  Response body:', e.body.substring(0, 400));
+            process.exit(1);
+          }
+          // attach() succeeded — skip getPosition() validation.
+          // With keepAlive, the connection is shared and getStack via the
+          // in-process daemon will use the same AdtHttp + same TCP socket.
+          positionResult = { position: {}, source: [] };
+          session = candidateSession;
+        }
         break;
       }
 
@@ -799,93 +876,53 @@ async function cmdAttach(args, config, adt) {
         if (!jsonOutput) process.stderr.write('  Listener timed out waiting for other session to finish.\n\n');
         process.exit(0);
       }
-      console.error('\n  Timeout: No breakpoint was hit within 4 minutes.\n');
+      console.error(`\n  Timeout: No breakpoint was hit within ${maxListenSeconds}s.\n`);
       process.exit(1);
     }
   }
 
-  const session = new DebugSession(adt, sessionId);
-
-  // If we got here via the listener (not --session override), we have a
-  // DEBUGGEE_ID and need to call ?method=attach to register as the active
-  // debugger for that work process. Without this step, all subsequent calls
-  // (getStack, getVariables, step) return "noSessionAttached" (T100-530).
-  if (!sessionIdOverride) {
-    if (!jsonOutput) {
-      process.stderr.write('\n  Attaching to debug session...\n');
-    }
+  // When using --session override (no listener), do attach+getPosition here.
+  if (sessionIdOverride) {
+    session = new DebugSession(adt, sessionId);
+    // getPosition is best-effort for --session override (e.g. human REPL recovery)
     try {
-      await session.attach(sessionId, (config.user || '').toUpperCase());
+      positionResult = await session.getPosition();
     } catch (e) {
-      printHttpError(e, { prefix: '  Error during attach' });
-      if (e.body) console.error('  Response body:', e.body.substring(0, 400));
-      process.exit(1);
+      positionResult = { position: {}, source: [] };
     }
   }
 
-  // Fetch position + variables now that we have a live session
-  try {
-    positionResult = await session.getPosition();
-  } catch (e) {
-    // Position fetch is best-effort; proceed with empty state
-    positionResult = { position: {}, source: [] };
-  }
-
-  // Dummy loop body retained for structural compatibility (never executes)
-  if (false) {
-    const MAX_POLLS = 0;
-    const POLL_INTERVAL = 0;
-    for (let i = 0; i < MAX_POLLS; i++) {
-      try {
-        const frames = await session.getStack();
-        if (frames && frames.length > 0 && frames[0].line > 0) {
-          positionResult = await session.getPosition();
-          break;
-        }
-      } catch (e) {
-        // Stack not ready yet — keep polling
-      }
-      await new Promise(r => setTimeout(r, POLL_INTERVAL));
-    }
+  // session and positionResult are now set (either via listener loop or --session override)
+  if (!session) {
+    // Should not reach here — listener loop either sets session or exits
+    console.error('\n  Internal error: session not initialized after attach.\n');
+    process.exit(1);
   }
+  if (!positionResult) positionResult = { position: {}, source: [] };
 
   const { position, source } = positionResult;
   saveActiveSession(config, { sessionId, position });
 
   if (jsonOutput) {
-    // Spawn the background daemon to hold the stateful ADT HTTP connection.
-    // The daemon process inherits the exact SAP_SESSIONID cookie + CSRF token
-    // via the snapshot env var, so it reuses the same ABAP work process.
+    // Run the socket server in-process so all ADT requests reuse the same TCP
+    // connection that called attach(). SAP pins the debug session to the
+    // originating TCP connection — a new connection returns HTTP 400.
     const socketPath = _getDaemonSocketPath ? _getDaemonSocketPath(config) : null;
     if (socketPath) {
-      const snapshot = { csrfToken: adt.csrfToken, cookies: adt.cookies };
-      const daemonEnv = {
-        ...process.env,
-        DEBUG_DAEMON_MODE:            '1',
-        DEBUG_DAEMON_CONFIG:          JSON.stringify(config),
-        DEBUG_DAEMON_SESSION_ID:      sessionId,
-        DEBUG_DAEMON_SOCK_PATH:       socketPath,
-        DEBUG_DAEMON_SESSION_SNAPSHOT: JSON.stringify(snapshot)
-      };
-      const daemonScript = path.resolve(__dirname, '../utils/debug-daemon.js');
-      const child = spawn(process.execPath, [daemonScript], {
-        detached: true,
-        stdio: ['ignore', 'ignore', 'ignore'],
-        env: daemonEnv
-      });
-      child.unref();
-
-      // Wait for daemon socket to appear (up to 5 s) before returning JSON
-      try {
-        await waitForSocket(socketPath, 5000);
-        // Persist socket path in session state so step/vars/stack/terminate find it
-        saveActiveSession(config, { sessionId, position, socketPath });
-      } catch (e) {
-        // Non-fatal: fall back to stateless direct-ADT mode
-      }
+      // Save cookies so terminate can release the frozen WP even if the daemon is gone
+      saveActiveSession(config, { sessionId, position, socketPath, cookies: adt.cookies });
     }
 
+    // Emit session JSON now so the caller (script / AI) knows the BP was hit.
     console.log(JSON.stringify({ session: sessionId, position, source }));
+
+    if (socketPath) {
+      const { startDaemon } = require('../utils/debug-daemon');
+      // Blocks until terminate is called or idle timeout — intentional.
+      // The process stays alive as the IPC socket server, holding the ADT
+      // TCP connection open. The caller runs this command in the background (&).
+      await startDaemon(session, socketPath);
+    }
     return;
   }
 
@@ -1050,8 +1087,8 @@ async function cmdVars(args, config, adt) {
  *   LO_FACTORY->MT_COMMAND_MAP   (object attr → table)
  *   LS_DATA->COMPONENT            (structure field)
  *
- * When a daemon socket is active, uses daemon IPC for single-segment paths.
- * Multi-segment paths always run directly against ADT (DebugSession.expandPath).
+ * When a daemon socket is active, uses daemon IPC for both single-segment and
+ * multi-segment paths so the stateful ADT session is always reused.
  */
 async function cmdExpand(expandName, sessionId, socketPath, config, adt, jsonOutput) {
   // Split on -> to detect path notation. Also handle --> typos by stripping stray dashes.
@@ -1059,20 +1096,37 @@ async function cmdExpand(expandName, sessionId, socketPath, config, adt, jsonOut
   //   [N]-FIELD  → [N]->FIELD   (array row then struct field)
   //   *-FIELD    → *->FIELD     (dereference then struct field: lr_request->*-files)
   const normalizedName = expandName
+    .replace(/^([A-Za-z0-9_@]+)\[(\d+)\]$/, '$1->[$2]') // VAR[N]       → VAR->[N]   (exact match)
+    .replace(/([A-Za-z0-9_@]+)\[(\d+)\]->/g, '$1->[$2]->') // VAR[N]->X → VAR->[N]->X (mid-path)
     .replace(/\](-(?!>))/g,  ']->') // [N]-FIELD → [N]->FIELD
     .replace(/\*(-(?!>))/g,  '*->'); // *-FIELD   → *->FIELD
   const pathParts = normalizedName.split('->').map(s => s.replace(/^-+|-+$/g, '').trim()).filter(Boolean);
 
-  // Multi-segment path: must go direct (daemon IPC only handles one level at a time)
+  // Multi-segment path: route through daemon when available (daemon holds stateful ADT session)
   if (pathParts.length > 1) {
-    if (!adt.csrfToken) await adt.fetchCsrfToken();
-    const session = new DebugSession(adt, sessionId);
     let result;
-    try {
-      result = await session.expandPath(pathParts);
-    } catch (err) {
-      printHttpError(err, { prefix: '  Error' });
-      process.exit(1);
+    if (socketPath) {
+      let resp;
+      try {
+        resp = await sendDaemonCommand(socketPath, { cmd: 'expandPath', pathParts }, 60000);
+      } catch (err) {
+        printHttpError(err, { prefix: '  Error' });
+        process.exit(1);
+      }
+      if (!resp.ok) {
+        console.error(`\n  Error: ${resp.error}\n`);
+        process.exit(1);
+      }
+      result = { variable: resp.variable, children: resp.children };
+    } else {
+      if (!adt.csrfToken) await adt.fetchCsrfToken();
+      const session = new DebugSession(adt, sessionId);
+      try {
+        result = await session.expandPath(pathParts);
+      } catch (err) {
+        printHttpError(err, { prefix: '  Error' });
+        process.exit(1);
+      }
     }
     const { variable: target, children } = result;
     return _printExpandResult(expandName, target, children, jsonOutput);
@@ -1243,20 +1297,29 @@ async function cmdTerminate(args, config, adt) {
 
   // Prefer daemon IPC — daemon calls session.terminate() then exits itself
   if (socketPath) {
-    let resp;
+    let ipcSucceeded = false;
     try {
-      resp = await sendDaemonCommand(socketPath, { cmd: 'terminate' }, 30000);
+      const resp = await sendDaemonCommand(socketPath, { cmd: 'terminate' }, 30000);
+      if (resp && resp.ok) ipcSucceeded = true;
     } catch (err) {
-      // Socket may be gone already (daemon crashed or timed out) — treat as terminated
-      resp = { ok: true, terminated: true };
+      // Socket is gone (daemon crashed or was killed) — fall through to direct ADT call
     }
-    clearActiveSession(config);
-    if (jsonOutput) {
-      console.log(JSON.stringify({ terminated: resp.ok ? true : resp.error }));
+    if (ipcSucceeded) {
+      clearActiveSession(config);
+      if (jsonOutput) {
+        console.log(JSON.stringify({ terminated: true }));
+        return;
+      }
+      console.log('\n  Debug session terminated.\n');
       return;
     }
-    console.log('\n  Debug session terminated.\n');
-    return;
+    // IPC failed — daemon is gone but ABAP WP may still be frozen.
+    // Use stored session cookies to release the WP via direct ADT call.
+    const savedState = loadActiveSession(config);
+    if (savedState && savedState.cookies && sessionId) {
+      adt.cookies = savedState.cookies;
+    }
+    // Fall through to direct ADT terminate below
   }
 
   // Fallback: direct ADT call
@@ -1289,32 +1352,6 @@ async function cmdTerminate(args, config, adt) {
 
 // ─── Daemon IPC helpers ───────────────────────────────────────────────────────
 
-/**
- * Wait for the daemon's Unix socket to appear (after spawn).
- * @param {string} socketPath
- * @param {number} timeoutMs
- */
-function waitForSocket(socketPath, timeoutMs) {
-  return new Promise((resolve, reject) => {
-    const deadline = Date.now() + timeoutMs;
-    function check() {
-      const client = net.createConnection(socketPath);
-      client.on('connect', () => {
-        client.destroy();
-        resolve();
-      });
-      client.on('error', () => {
-        if (Date.now() >= deadline) {
-          reject(new Error('Timeout waiting for debug daemon to start'));
-        } else {
-          setTimeout(check, 100);
-        }
-      });
-    }
-    check();
-  });
-}
-
 /**
  * Send one JSON command to the daemon and return the parsed JSON response.
  * @param {string} socketPath

package/src/commands/guide.js

@@ -178,6 +178,13 @@ module.exports = {
     console.log('');
   },
 
+  _extractAiContent(content) {
+    const marker = '<!-- AI-CONDENSED-START -->';
+    const markerIndex = content.indexOf(marker);
+    if (markerIndex === -1) return content;
+    return content.slice(markerIndex + marker.length).trimStart();
+  },
+
   async execute(args) {
     if (args.includes('--migrate')) {
       return this._runMigrate(args);
@@ -197,6 +204,16 @@ module.exports = {
 
     const content = fs.readFileSync(filePath, 'utf8');
 
+    if (args.includes('--ai')) {
+      const aiContent = this._extractAiContent(content);
+      if (args.includes('--json')) {
+        console.log(JSON.stringify({ path: filePath, content: aiContent }));
+        return;
+      }
+      console.log(aiContent);
+      return;
+    }
+
     if (args.includes('--json')) {
       console.log(JSON.stringify({ path: filePath, content }));
       return;

package/src/commands/inspect.js

@@ -248,7 +248,7 @@ module.exports = {
   requiresVersionCheck: true,
 
   async execute(args, context) {
-    const { loadConfig, AbapHttp } = context;
+    const { loadConfig, AbapHttp, getInspectConfig } = context;
 
     if (args.includes('--help') || args.includes('-h')) {
       console.log(`
@@ -287,9 +287,11 @@ Examples:
 
     const filesSyntaxCheck = args[filesArgIndex + 1].split(',').map(f => f.trim());
 
-    // Parse optional --variant parameter
+    // Parse optional --variant parameter; fall back to project config
     const variantArgIndex = args.indexOf('--variant');
-    const variant = variantArgIndex !== -1 ? args[variantArgIndex + 1] : null;
+    const variantArg = variantArgIndex !== -1 ? args[variantArgIndex + 1] : null;
+    const inspectConfig = getInspectConfig();
+    const variant = variantArg || inspectConfig.variant || null;
 
     // Parse optional --junit-output parameter
     const junitArgIndex = args.indexOf('--junit-output');
@@ -298,7 +300,8 @@ Examples:
     if (!jsonOutput) {
       console.log(`\n  Inspect for ${filesSyntaxCheck.length} file(s)`);
       if (variant) {
-        console.log(`  Using variant: ${variant}`);
+        const source = variantArg ? '' : ' (from project config)';
+        console.log(`  Using variant: ${variant}${source}`);
       }
       if (junitOutput) {
         console.log(`  JUnit output: ${junitOutput}`);

package/src/commands/pull.js

@@ -329,7 +329,8 @@ Examples:
       const jobId = result.JOB_ID || result.job_id;
       const message = result.MESSAGE || result.message;
       const errorDetail = result.ERROR_DETAIL || result.error_detail;
-      const activatedCount = result.ACTIVATED_COUNT || result.activated_count || 0;
+      const activatedCountRaw = result.ACTIVATED_COUNT ?? result.activated_count ?? null;
+      const activatedCount = activatedCountRaw || 0;
       const failedCount = result.FAILED_COUNT || result.failed_count || 0;
       const logMessages = result.LOG_MESSAGES || result.log_messages || [];
       const activatedObjects = result.ACTIVATED_OBJECTS || result.activated_objects || [];
@@ -362,6 +363,9 @@ Examples:
       if (success === 'X' || success === true) {
         console.log(`✅ Pull completed successfully!`);
         console.log(`   Message: ${message || 'N/A'}`);
+        if (activatedCountRaw !== null && activatedCount === 0 && activatedObjects.length === 0 && files && !isRepull) {
+          console.warn(`⚠️  ACTIVATED_COUNT: 0 — no objects were activated. Check for unpushed commits: git log origin/<branch>..HEAD`);
+        }
       } else if (failedCount === 0 && failedObjects.length === 0 &&
                  activatedCount === 0 && logMessages.length === 0 &&
                  (!message || /activation cancelled|nothing to activate|already active/i.test(message))) {
@@ -522,20 +526,40 @@ Examples:
           const quotedPaths = diffFiles.map(f => `"${f.relPath}"`).join(' ');
           execSync(`git add ${quotedPaths}`, { cwd: process.cwd() });
 
-          // 3. Amend last commit
+          // 3. Capture pre-amend SHA before amending (used for --force-with-lease below)
+          const preAmendSha = execSync('git rev-parse HEAD', { cwd: process.cwd(), stdio: 'pipe' }).toString().trim();
+
+          // 3b. Check whether origin/<branch> already exists on the remote.
+          //     Use git ls-remote rather than rev-parse origin/<branch> because the local
+          //     remote-tracking ref may not exist even when the branch is on the remote
+          //     (e.g. after a push that only wrote branch config but not refs/remotes/).
+          let remoteRefExists = false;
+          try {
+            const lsOut = execSync(`git ls-remote origin "refs/heads/${branch}"`, { cwd: process.cwd(), stdio: 'pipe' }).toString().trim();
+            remoteRefExists = lsOut.length > 0;
+          } catch (_) { /* cannot reach remote — treat as new branch */ }
+
+          // 4. Amend last commit
           execSync('git commit --amend --no-edit', { cwd: process.cwd() });
 
-          // 4. Push with force-with-lease; fetch first so tracking ref is current
-          //    (the remote may have been force-pushed by another process between our last
-          //    fetch and this push — a fetch makes --force-with-lease reliable)
+          // 5. Push with force-with-lease using the pre-amend SHA as the expected remote value.
+          //    Using --force-with-lease=<refname>:<sha> tells git: "the remote must have exactly
+          //    <preAmendSha> — if it does, replace it with our amended commit".
+          //    Plain --force-with-lease (no sha) re-checks the tracking ref which was just updated
+          //    by git fetch, making it always fail after an amend.
           let pushed = false;
           try {
-            try { execSync('git fetch origin', { cwd: process.cwd(), stdio: 'pipe' }); } catch (_) { /* no remote is fine */ }
             // Retry the push up to 3 times on transient server errors (e.g. GitHub Enterprise 500)
             let pushErr;
             for (let attempt = 1; attempt <= 3; attempt++) {
               try {
-                execSync('git push --force-with-lease', { cwd: process.cwd(), stdio: 'pipe' });
+                // If origin/<branch> exists: use --force-with-lease=branch:preAmendSha so we only
+                // overwrite if the remote still has the pre-amend commit (safe concurrent guard).
+                // If origin/<branch> doesn't exist yet: plain push with --set-upstream (no lease needed).
+                const pushCmd = remoteRefExists
+                  ? `git push --set-upstream origin ${branch} --force-with-lease=${branch}:${preAmendSha}`
+                  : `git push --set-upstream origin ${branch}`;
+                execSync(pushCmd, { cwd: process.cwd(), stdio: 'pipe' });
                 pushed = true;
                 break;
               } catch (err) {
@@ -550,13 +574,7 @@ Examples:
               }
             }
           } catch (pushErr) {
-            const msg = (pushErr.stderr || pushErr.stdout || pushErr.message || '').toString();
-            if (msg.includes('no upstream branch') || msg.includes('has no upstream')) {
-              // Branch not yet pushed — set upstream and force push (amend requires force)
-              execSync(`git push --force-with-lease --set-upstream origin ${branch}`, { cwd: process.cwd(), stdio: 'pipe' });
-              pushed = true;
-            }
-            // Any other push error (no remote at all, auth failure, etc.) → skip silently
+            // Any push error (no remote, auth failure, etc.) → skip silently
           }
 
           if (pushed) {

package/src/commands/unit.js

@@ -166,8 +166,9 @@ async function runUnitTestForFile(sourceFile, csrfToken, config, coverage, http,
     // Handle uppercase keys from ABAP
     const success = result.SUCCESS || result.success;
     const testCount = result.TEST_COUNT || result.test_count || 0;
-    const passedCount = result.PASSED_COUNT || result.passed_count || 0;
     const failedCount = result.FAILED_COUNT || result.failed_count || 0;
+    // ABAP AUnit API does not return individual passing method names — derive passed count
+    const passedCount = testCount - failedCount;
     const message = result.MESSAGE || result.message || '';
     const errors = result.ERRORS || result.errors || [];
 

package/src/commands/view.js

@@ -151,7 +151,7 @@ async function computeGlobalStarts(objName, sections, config) {
  * Returns 0 if no better line is found (falls back to METHOD statement).
  */
 function findFirstExecutableLine(lines) {
-  const declPattern = /^\s*(data|final|types|constants|class-data)[\s:(]/i;
+  const declPattern = /^\s*(data|final|types|constants|class-data|field-symbols)[\s:(</\[]/i;
   const methodPattern = /^\s*method\s+/i;
   const commentPattern = /^\s*[*"]/;
   // Program-level header/declaration keywords that are not executable statements

package/src/config.js

@@ -247,6 +247,17 @@ function getCoverageConfig() {
   };
 }
 
+/**
+ * Get inspect settings from project-level config (.abapgit-agent.json)
+ * @returns {{ variant: string|null }}
+ */
+function getInspectConfig() {
+  const projectConfig = loadProjectConfig();
+  return {
+    variant: projectConfig?.inspect?.variant || null,
+  };
+}
+
 module.exports = {
   loadConfig,
   getAbapConfig,
@@ -261,5 +272,6 @@ module.exports = {
   getTransportHookConfig,
   getTransportSettings,
   getScratchWorkspace,
-  getCoverageConfig
+  getCoverageConfig,
+  getInspectConfig
 };