abapgit-agent 1.10.1 → 1.11.1

package/.abapGitAgent.example

@@ -5,6 +5,7 @@
   "user": "TECH_USER",
   "password": "your-password",
   "language": "EN",
+  "protocol": "https",
   "gitUsername": "github-username",
   "gitPassword": "github-token",
   "referenceFolder": "~/abap-reference"

package/abap/CLAUDE.md

@@ -308,32 +308,26 @@ abapgit-agent debug list    # confirm it was registered
 
 **Step 2 — attach and trigger**
 
-Two modes depending on context:
+Best practice: individual sequential calls. Once the daemon is running and
+the session is saved to the state file, each `vars/stack/step` command is a
+plain standalone call — no `--session` flag needed.
 
-*Interactive (human in a terminal):*
 ```bash
-# Terminal 1 — attach (blocks waiting for breakpoint, opens REPL on hit)
-abapgit-agent debug attach
-
-# Terminal 2 — trigger (any command that calls the backend)
-abapgit-agent unit --files src/zcl_my_class.clas.testclasses.abap
-abapgit-agent inspect --files src/zcl_my_class.clas.abap
-```
-
-*Scripted (AI / automation) — best practice: individual sequential calls:*
-
-Once the daemon is running and the session is saved to the state file, each
-`vars/stack/step` command is a plain standalone call — no bash script needed.
-
-```bash
-# Step 1: start attach listener in background (spawns a daemon, saves session to state file)
+# Start attach listener in background (spawns a daemon, saves session to state file)
 abapgit-agent debug attach --json > /tmp/attach.json 2>&1 &
-sleep 2
 
-# Step 2: trigger in background — MUST stay alive for the whole session
+# Rule 1: wait for "Listener active" in the output, THEN fire the trigger.
+# attach --json prints "Listener active" to stderr (captured in attach.json) the
+# moment the long-poll POST is about to be sent to ADT.  Waiting for this marker
+# is reliable under any system load; a blind sleep may fire the trigger before
+# ADT has a registered listener, causing the breakpoint hit to be missed.
+until grep -q "Listener active" /tmp/attach.json 2>/dev/null; do sleep 0.3; done
+sleep 1   # brief extra window for the POST to reach ADT
+
+# Trigger in background — MUST stay alive for the whole session
 abapgit-agent unit --files src/zcl_my_class.clas.testclasses.abap > /tmp/trigger.json 2>&1 &
 
-# Step 3: poll until breakpoint fires and session JSON appears in attach output
+# Poll until breakpoint fires and session JSON appears in attach output
 SESSION=""
 for i in $(seq 1 30); do
   sleep 0.5
@@ -341,40 +335,29 @@ for i in $(seq 1 30); do
   [ -n "$SESSION" ] && break
 done
 
-# Step 4: inspect and step — each is an individual call, no --session needed
+# Inspect and step — each is an individual call, no --session needed
 abapgit-agent debug stack --json
 abapgit-agent debug vars  --json
 abapgit-agent debug vars  --expand LS_OBJECT --json
 abapgit-agent debug step  --type over --json
 abapgit-agent debug vars  --json
 
-# Step 5: ALWAYS release the ABAP work process before finishing
+# ALWAYS release the ABAP work process before finishing
 abapgit-agent debug step --type continue --json
 
-# Step 6: check trigger result
+# Check trigger result
 cat /tmp/trigger.json
 rm -f /tmp/attach.json /tmp/trigger.json
 ```
 
 > **Four rules for scripted mode:**
-> 1. `sleep 2` after starting attach — the listener must register on the server before the trigger fires
+> 1. Wait for `"Listener active"` in the attach output before firing the trigger — this message is printed to stderr (captured in `attach.json`) the moment the listener POST is about to reach ADT. A blind `sleep` is not reliable under system load.
 > 2. Keep the trigger process alive in the background for the entire session — if it exits, the ABAP work process is released and the session ends
 > 3. Always finish with `step --type continue` — this releases the frozen work process so the trigger can complete normally
 > 4. **Never pass `--session` to `step/vars/stack`** — it bypasses the daemon IPC and causes `noSessionAttached`. Omit it and let commands auto-load from the saved state file.
 
 **Step 3 — step through and inspect**
 
-*Interactive REPL commands (after `attach` without `--json`):*
-```
-  debug> v          — show all variables
-  debug> x LT_DATA  — expand a table or structure
-  debug> n          — step over
-  debug> s          — step into
-  debug> bt         — call stack
-  debug> q          — detach (program continues); kill — hard abort
-```
-
-*Scripted commands (after `attach --json`) — omit `--session`, commands auto-load from state file:*
 ```bash
 abapgit-agent debug vars   --json                        # all variables
 abapgit-agent debug vars   --name LV_RESULT --json       # one variable
@@ -396,6 +379,24 @@ abapgit-agent debug delete --all
 
 This project's workflow mode is configured in `.abapGitAgent` under `workflow.mode`.
 
+### Project-Level Config (`.abapgit-agent.json`)
+
+Checked into the repository — applies to all developers. **Read this file at the start of every session.**
+
+| Setting | Values | Default | Effect |
+|---------|--------|---------|--------|
+| `safeguards.requireFilesForPull` | `true`/`false` | `false` | Requires `--files` on every pull |
+| `safeguards.disablePull` | `true`/`false` | `false` | Disables pull entirely (CI/CD-only projects) |
+| `conflictDetection.mode` | `"abort"`/`"ignore"` | `"abort"` | Whether to abort pull on conflict |
+| `transports.hook.path` | string | `null` | Path to JS module that auto-selects a transport for pull |
+| `transports.hook.description` | string | `null` | Optional label shown when the hook runs |
+| `transports.allowCreate` | `true`/`false` | `true` | When `false`, `transport create` is blocked |
+| `transports.allowRelease` | `true`/`false` | `true` | When `false`, `transport release` is blocked |
+
+CLI `--conflict-mode` always overrides the project config for a single run.
+
+See **AI Tool Guidelines** below for how to react to each setting.
+
 ### Workflow Modes
 
 | Mode | Branch Strategy | Rebase Before Pull | Create PR |
@@ -571,6 +572,37 @@ abapgit-agent pull --files src/zcl_auth_handler.clas.abap
 3. ✓ `git pull origin <default>` before push
 4. ✗ Don't create feature branches
 
+**Read `.abapgit-agent.json` to determine project safeguards and conflict detection:**
+
+**When `safeguards.requireFilesForPull = true`:**
+1. ✓ Always include `--files` in every `pull` command
+2. ✓ Never run `abapgit-agent pull` without `--files`
+3. ✗ Don't suggest or run a full pull without specifying files
+
+**When `safeguards.requireFilesForPull = false` or not set:**
+1. ✓ `--files` is optional — use it for speed, omit for full pull
+
+**When `safeguards.disablePull = true`:**
+1. ✗ Do not run `abapgit-agent pull` at all
+2. ✓ Inform the user that pull is disabled for this project (CI/CD only)
+
+**When `conflictDetection.mode = "ignore"` or not set:**
+1. ✓ Run `pull` normally — no conflict flags needed
+2. ✗ Don't add `--conflict-mode` unless user explicitly asks
+
+**When `conflictDetection.mode = "abort"`:**
+1. ✓ Conflict detection is active — pull aborts if ABAP system was edited since last pull
+2. ✓ If pull is aborted with conflict error, inform user and suggest `--conflict-mode ignore` to override for that run
+3. ✗ Don't silently add `--conflict-mode ignore` — always tell the user about the conflict
+
+**When `transports.allowCreate = false`:**
+1. ✗ Do not run `abapgit-agent transport create`
+2. ✓ Inform the user that transport creation is disabled for this project
+
+**When `transports.allowRelease = false`:**
+1. ✗ Do not run `abapgit-agent transport release`
+2. ✓ Inform the user that transport release is disabled for this project
+
 ---
 
 ## Development Workflow (Detailed)
@@ -600,6 +632,7 @@ abapgit-agent pull --files src/zcl_auth_handler.clas.abap
        │
        ▼
 6. Activate → abapgit-agent pull --files src/file.clas.abap
+       │         (behaviour depends on .abapgit-agent.json — see AI Tool Guidelines)
        │
        ▼
 7. Verify → Check pull output
@@ -791,6 +824,9 @@ abapgit-agent syntax --files src/zcl_class1.clas.abap,src/zif_intf1.intf.abap,sr
 # 2. Pull/activate AFTER pushing to git
 abapgit-agent pull --files src/zcl_class1.clas.abap,src/zcl_class2.clas.abap
 
+# Override conflict detection for a single pull (e.g. deliberate branch switch)
+abapgit-agent pull --files src/zcl_class1.clas.abap --conflict-mode ignore
+
 # 3. Inspect AFTER pull (for errors or unsupported types)
 abapgit-agent inspect --files src/zcl_class1.clas.abap
 

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, getSafeguards } = require('../src/config');
+const { loadConfig, getTransport, isAbapIntegrationEnabled, getSafeguards, getConflictSettings, getTransportSettings } = require('../src/config');
 
 // Get terminal width for responsive table
 const getTermWidth = () => process.stdout.columns || 80;
@@ -55,7 +55,8 @@ async function main() {
     ref: require('../src/commands/ref'),
     init: require('../src/commands/init'),
     pull: require('../src/commands/pull'),
-    upgrade: require('../src/commands/upgrade')
+    upgrade: require('../src/commands/upgrade'),
+    transport: require('../src/commands/transport')
   };
 
   // Check if this is a modular command
@@ -102,7 +103,9 @@ To enable integration:
       loadConfig,
       AbapHttp,
       getTransport,
-      getSafeguards
+      getSafeguards,
+      getConflictSettings,
+      getTransportSettings
     };
 
     // Execute command
@@ -124,7 +127,7 @@ To enable integration:
 main().catch((err) => {
   // Known CLI errors (e.g. pull conflict) already printed their own output — skip re-printing.
   // For all other unexpected errors, print the message without the stack trace.
-  if (!err._isPullError) {
+  if (!err._isPullError && !err._isTransportError) {
     console.error(err.message || err);
   }
   process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abapgit-agent",
-  "version": "1.10.1",
+  "version": "1.11.1",
   "description": "ABAP Git Agent - Pull and activate ABAP code via abapGit from any git repository",
   "main": "src/index.js",
   "files": [
@@ -42,6 +42,7 @@
     "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",
+    "test:full-pull": "node tests/run-all.js --full-pull",
     "test:conflict": "node tests/run-all.js --conflict",
     "pull": "node bin/abapgit-agent",
     "release": "node scripts/release.js",

package/src/commands/debug.js

@@ -583,7 +583,7 @@ async function cmdAttach(args, config, adt) {
     let firstPoll = true;
 
     for (let i = 0; i < (takenOver ? MAX_TAKEOVER_POLLS : MAX_POLLS); i++) {
-      if (firstPoll && !jsonOutput) {
+      if (firstPoll) {
         process.stderr.write('  Listener active — trigger your ABAP program now.\n');
         firstPoll = false;
       }

package/src/commands/pull.js

@@ -9,7 +9,7 @@ module.exports = {
   requiresVersionCheck: true,
 
   async execute(args, context) {
-    const { loadConfig, AbapHttp, gitUtils, getTransport, getSafeguards } = context;
+    const { loadConfig, AbapHttp, gitUtils, getTransport, getSafeguards, getConflictSettings, getTransportSettings } = context;
 
     // Check project-level safeguards
     const safeguards = getSafeguards();
@@ -36,9 +36,9 @@ module.exports = {
     let gitUrl = urlArgIndex !== -1 ? args[urlArgIndex + 1] : null;
     let branch = branchArgIndex !== -1 ? args[branchArgIndex + 1] : gitUtils.getBranch();
     let files = null;
-    let conflictMode = conflictModeArgIndex !== -1 ? args[conflictModeArgIndex + 1] : 'abort';
+    let conflictMode = conflictModeArgIndex !== -1 ? args[conflictModeArgIndex + 1] : getConflictSettings().mode;
 
-    // Transport: CLI arg takes priority, then config/environment, then null
+    // Transport: CLI arg takes priority, then config/environment, then selector
     let transportRequest = null;
     if (transportArgIndex !== -1 && transportArgIndex + 1 < args.length) {
       // Explicit --transport argument
@@ -48,8 +48,39 @@ module.exports = {
       transportRequest = getTransport();
     }
 
+    // Auto-detect URL early (needed for transport_required check)
+    if (!gitUrl) {
+      gitUrl = gitUtils.getRemoteUrl();
+      if (!gitUrl) {
+        console.error('Error: Not in a git repository or no remote configured.');
+        console.error('Either run from a git repo, or specify --url <git-url>');
+        process.exit(1);
+      }
+      if (!jsonOutput) {
+        console.log(`📌 Auto-detected git remote: ${gitUrl}`);
+      }
+    }
+
     if (filesArgIndex !== -1 && filesArgIndex + 1 < args.length) {
       files = args[filesArgIndex + 1].split(',').map(f => f.trim());
+
+      // Validate that every file has a recognised ABAP source extension
+      // (.abap or .asddls) — XML metadata files must NOT be passed here
+      const ABAP_SOURCE_EXTS = new Set(['abap', 'asddls']);
+      const nonSourceFiles = files.filter(f => {
+        const base = f.split('/').pop(); // strip directory
+        const parts = base.split('.');
+        const ext = parts[parts.length - 1].toLowerCase();
+        return parts.length < 3 || !ABAP_SOURCE_EXTS.has(ext);
+      });
+      if (nonSourceFiles.length > 0) {
+        console.error('❌ Error: --files only accepts ABAP source files (.abap, .asddls).');
+        console.error('   The following file(s) are not ABAP source files:');
+        nonSourceFiles.forEach(f => console.error(`     ${f}`));
+        console.error('   Tip: pass the source file, not the XML metadata file.');
+        console.error('   Example: --files src/zcl_my_class.clas.abap');
+        process.exit(1);
+      }
     }
 
     // SAFEGUARD 2: Check if files are required but not provided
@@ -64,15 +95,52 @@ module.exports = {
       process.exit(1);
     }
 
-    if (!gitUrl) {
-      gitUrl = gitUtils.getRemoteUrl();
-      if (!gitUrl) {
-        console.error('Error: Not in a git repository or no remote configured.');
-        console.error('Either run from a git repo, or specify --url <git-url>');
-        process.exit(1);
+    // Auto-select transport when none configured and not in JSON mode
+    if (!transportRequest && !jsonOutput) {
+      const { selectTransport, isNonInteractive, _getTransportHookConfig } = require('../utils/transport-selector');
+
+      // Check if this package requires a transport before showing the interactive
+      // picker. Skip the status round-trip in non-interactive mode — selectTransport
+      // already returns null there without prompting, so the extra HTTP call is wasted.
+      let transportRequired = true; // Safe default: assume transport needed
+      if (!isNonInteractive()) {
+        try {
+          const config = loadConfig();
+          const http = new AbapHttp(config);
+          const csrfToken = await http.fetchCsrfToken();
+          const statusResult = await http.post('/sap/bc/z_abapgit_agent/status', { url: gitUrl }, { csrfToken });
+          if (statusResult.transport_required === false || statusResult.transport_required === 'false') {
+            transportRequired = false;
+          }
+        } catch (e) {
+          // Status check failed — proceed with selector as safe default
+        }
       }
-      if (!jsonOutput) {
-        console.log(`📌 Auto-detected git remote: ${gitUrl}`);
+
+      if (transportRequired) {
+        const config = loadConfig();
+        const http = new AbapHttp(config);
+        transportRequest = await selectTransport(config, http, loadConfig, AbapHttp, getTransportSettings);
+
+        // If a hook was configured but returned no transport, handle based on context
+        if (transportRequest === null) {
+          const hookConfig = _getTransportHookConfig();
+          if (hookConfig && hookConfig.hook) {
+            if (isNonInteractive()) {
+              // Non-interactive (AI/CI): fail — a configured hook must return a transport
+              console.error('❌ Error: transport hook returned no transport request.');
+              console.error(`   Hook: ${hookConfig.hook}`);
+              if (hookConfig.description) console.error(`   ${hookConfig.description}`);
+              process.exit(1);
+            } else {
+              // Interactive (TTY): warn and fall through to the picker
+              process.stderr.write(`⚠️  Transport hook returned no transport request (${hookConfig.hook}).\n`);
+              process.stderr.write('   Please select one manually:\n');
+              const { interactivePicker } = require('../utils/transport-selector');
+              transportRequest = await interactivePicker(http);
+            }
+          }
+        }
       }
     }
 

package/src/commands/status.js

@@ -32,7 +32,9 @@ module.exports = {
             console.log('   Repository: ✅ Created');
             const pkg = result.package || result.PACKAGE || 'N/A';
             const key = result.key || result.KEY || result.REPO_KEY || result.repo_key || 'N/A';
+            const transportRequired = result.transport_required === true || result.transport_required === 'true';
             console.log(`      Package: ${pkg}`);
+            console.log(`      Transport required: ${transportRequired ? 'Yes' : 'No'}`);
             console.log(`      URL: ${repoUrl}`);
             console.log(`      Key: ${key}`);
           } else {

package/src/commands/transport.js

@@ -0,0 +1,290 @@
+/**
+ * Transport command - List and manage SAP transport requests
+ */
+
+const VALID_SCOPES = ['mine', 'task', 'all'];
+const VALID_SUBCOMMANDS = ['list', 'create', 'check', 'release'];
+const VALID_TYPES = ['workbench', 'customizing'];
+
+module.exports = {
+  name: 'transport',
+  description: 'List and manage SAP transport requests',
+  requiresAbapConfig: true,
+  requiresVersionCheck: false,
+
+  async execute(args, context) {
+    const { loadConfig, AbapHttp, getTransportSettings } = context;
+
+    const jsonOutput = args.includes('--json');
+
+    // Determine subcommand (first positional arg, default to 'list')
+    const subcommand = args[0] && !args[0].startsWith('-') ? args[0] : 'list';
+
+    if (!VALID_SUBCOMMANDS.includes(subcommand)) {
+      console.error(`❌ Error: Unknown subcommand '${subcommand}'. Use: ${VALID_SUBCOMMANDS.join(', ')}`);
+      process.exit(1);
+    }
+
+    // Check project-level transport settings
+    const transportSettings = getTransportSettings();
+
+    if (subcommand === 'create' && !transportSettings.allowCreate) {
+      console.error(`❌ transport create is disabled for this project.`);
+      if (transportSettings.reason) console.error(`   Reason: ${transportSettings.reason}`);
+      console.error(`   This safeguard is configured in .abapgit-agent.json`);
+      const err = new Error('transport create disabled');
+      err._isTransportError = true;
+      throw err;
+    }
+
+    if (subcommand === 'release' && !transportSettings.allowRelease) {
+      console.error(`❌ transport release is disabled for this project.`);
+      if (transportSettings.reason) console.error(`   Reason: ${transportSettings.reason}`);
+      console.error(`   This safeguard is configured in .abapgit-agent.json`);
+      const err = new Error('transport release disabled');
+      err._isTransportError = true;
+      throw err;
+    }
+
+    const config = loadConfig();
+    const http = new AbapHttp(config);
+
+    try {
+      switch (subcommand) {
+        case 'list':
+          await this._list(args, http, jsonOutput);
+          break;
+        case 'create':
+          await this._create(args, http, jsonOutput);
+          break;
+        case 'check':
+          await this._check(args, http, jsonOutput);
+          break;
+        case 'release':
+          await this._release(args, http, jsonOutput);
+          break;
+      }
+    } catch (error) {
+      console.error(`❌ Error: ${error.message}`);
+      process.exit(1);
+    }
+  },
+
+  async _list(args, http, jsonOutput) {
+    const scopeIdx = args.indexOf('--scope');
+    const scope = scopeIdx !== -1 ? args[scopeIdx + 1] : 'mine';
+
+    if (!VALID_SCOPES.includes(scope)) {
+      console.error(`❌ Error: Invalid scope '${scope}'. Valid values: ${VALID_SCOPES.join(', ')}`);
+      process.exit(1);
+    }
+
+    const result = await http.get(`/sap/bc/z_abapgit_agent/transport?scope=${scope}`);
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    const transports = result.TRANSPORTS || result.transports || [];
+    const scopeLabel = { mine: 'mine', task: 'task — where I own or have a task', all: 'all' }[scope];
+
+    console.log(`\n📋 Open Transport Requests (${scopeLabel})\n`);
+
+    if (transports.length === 0) {
+      console.log('  No open transport requests found.');
+      console.log('');
+      console.log('  To create one: abapgit-agent transport create');
+      console.log('  To see more:   abapgit-agent transport list --scope task');
+      return;
+    }
+
+    // Table header
+    const numW = 2;
+    const trW = 12;
+    const descW = 33;
+    const ownerW = 12;
+    const dateW = 10;
+
+    const pad = (s, w) => String(s || '').substring(0, w).padEnd(w);
+    const header = `  ${'#'.padEnd(numW)}  ${pad('Number', trW)}  ${pad('Description', descW)}  ${pad('Owner', ownerW)}  ${'Date'}`;
+    const divider = `  ${'─'.repeat(numW)}  ${'─'.repeat(trW)}  ${'─'.repeat(descW)}  ${'─'.repeat(ownerW)}  ${'─'.repeat(dateW)}`;
+
+    console.log(header);
+    console.log(divider);
+
+    transports.forEach((t, i) => {
+      const num = t.NUMBER || t.number || '';
+      const desc = t.DESCRIPTION || t.description || '';
+      const owner = t.OWNER || t.owner || '';
+      const date = t.DATE || t.date || '';
+      console.log(`  ${String(i + 1).padEnd(numW)}  ${pad(num, trW)}  ${pad(desc, descW)}  ${pad(owner, ownerW)}  ${date}`);
+    });
+
+    console.log('');
+    console.log(`  ${transports.length} transport(s) found.`);
+    console.log('');
+    console.log(`  To use one: abapgit-agent pull --transport ${(transports[0].NUMBER || transports[0].number || 'DEVK900001')}`);
+
+    if (scope === 'mine') {
+      console.log('  To switch scope:');
+      console.log('    transport list --scope task   transports where I have a task');
+      console.log('    transport list --scope all     all open transports');
+    }
+  },
+
+  async _create(args, http, jsonOutput) {
+    const descIdx = args.indexOf('--description');
+    let description = descIdx !== -1 ? args[descIdx + 1] : null;
+
+    const typeIdx = args.indexOf('--type');
+    const type = typeIdx !== -1 ? args[typeIdx + 1] : 'workbench';
+
+    if (!VALID_TYPES.includes(type)) {
+      console.error(`❌ Error: Invalid type '${type}'. Valid values: ${VALID_TYPES.join(', ')}`);
+      process.exit(1);
+    }
+
+    // Prompt for description if not provided and running in TTY
+    if (!description && !jsonOutput && process.stdin.isTTY) {
+      description = await this._prompt('Description: ');
+    }
+
+    const csrfToken = await http.fetchCsrfToken();
+    const result = await http.post(
+      '/sap/bc/z_abapgit_agent/transport',
+      { action: 'CREATE', description: description || '', type },
+      { csrfToken }
+    );
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    const number = result.NUMBER || result.number;
+    const success = result.SUCCESS === true || result.success === true ||
+                    result.SUCCESS === 'X' || result.success === 'X';
+    const typeLabel = type === 'customizing' ? 'Customizing' : 'Workbench';
+
+    if (success && number) {
+      console.log(`\n✅ Transport ${number} created (${typeLabel} request).\n`);
+      console.log(`   To use it now: abapgit-agent pull --transport ${number}`);
+    } else {
+      const error = result.ERROR || result.error || result.MESSAGE || result.message || 'Could not create transport request';
+      console.error(`❌ Error: ${error}`);
+      process.exit(1);
+    }
+  },
+
+  async _check(args, http, jsonOutput) {
+    const numIdx = args.indexOf('--number');
+    if (numIdx === -1 || !args[numIdx + 1]) {
+      console.error('❌ Error: --number is required for transport check');
+      process.exit(1);
+    }
+    const number = args[numIdx + 1];
+
+    const csrfToken = await http.fetchCsrfToken();
+    const result = await http.post(
+      '/sap/bc/z_abapgit_agent/transport',
+      { action: 'CHECK', number },
+      { csrfToken }
+    );
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    const passed = result.PASSED === true || result.passed === true ||
+                   result.PASSED === 'X' || result.passed === 'X';
+    const issues = result.ISSUES || result.issues || [];
+    const desc = result.DESCRIPTION || result.description || '';
+    const owner = result.OWNER || result.owner || '';
+    const date = result.DATE || result.date || '';
+
+    console.log(`\n🔍 Checking transport ${number}...`);
+    if (desc) console.log(`\n   Description: ${desc}`);
+    if (owner) console.log(`   Owner: ${owner}`);
+    if (date) console.log(`   Date: ${date}`);
+
+    if (passed || issues.length === 0) {
+      console.log(`\n✅ Transport check passed — no issues found.`);
+      console.log(`   Ready to release: abapgit-agent transport release --number ${number}`);
+    } else {
+      console.log(`\n⚠️  Transport check completed with warnings/errors:\n`);
+
+      const typeW = 6;
+      const objW = 21;
+      const msgW = 44;
+      const pad = (s, w) => String(s || '').substring(0, w).padEnd(w);
+
+      console.log(`  ${'Type'.padEnd(typeW)}  ${'Object'.padEnd(objW)}  Message`);
+      console.log(`  ${'─'.repeat(typeW)}  ${'─'.repeat(objW)}  ${'─'.repeat(msgW)}`);
+
+      for (const issue of issues) {
+        const type = issue.TYPE || issue.type || '';
+        const objType = issue.OBJ_TYPE || issue.obj_type || '';
+        const objName = issue.OBJ_NAME || issue.obj_name || '';
+        const text = issue.TEXT || issue.text || '';
+        const icon = type === 'E' ? '❌' : type === 'W' ? '⚠️ ' : 'ℹ️ ';
+        const obj = objType && objName ? `${objType} ${objName}` : objType || objName;
+        console.log(`  ${icon.padEnd(typeW)}  ${pad(obj, objW)}  ${text}`);
+      }
+
+      console.log(`\n  ${issues.length} issue(s) found. Fix before releasing.`);
+    }
+  },
+
+  async _release(args, http, jsonOutput) {
+    const numIdx = args.indexOf('--number');
+    if (numIdx === -1 || !args[numIdx + 1]) {
+      console.error('❌ Error: --number is required for transport release');
+      process.exit(1);
+    }
+    const number = args[numIdx + 1];
+
+    const csrfToken = await http.fetchCsrfToken();
+    const result = await http.post(
+      '/sap/bc/z_abapgit_agent/transport',
+      { action: 'RELEASE', number },
+      { csrfToken }
+    );
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    const success = result.SUCCESS === true || result.success === true ||
+                    result.SUCCESS === 'X' || result.success === 'X';
+    const message = result.MESSAGE || result.message || '';
+    const error = result.ERROR || result.error || '';
+    const desc = result.DESCRIPTION || result.description || '';
+
+    if (success) {
+      console.log(`\n🚀 Releasing transport ${number}...`);
+      if (desc) console.log(`\n   Description: ${desc}`);
+      console.log(`\n✅ Transport ${number} released successfully.`);
+    } else {
+      console.error(`\n❌ Could not release transport ${number}.`);
+      if (error) {
+        console.error(`\n   Error: ${error}`);
+      } else if (message) {
+        console.error(`\n   Error: ${message}`);
+      }
+    }
+  },
+
+  _prompt(question) {
+    const readline = require('readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+    return new Promise((resolve) => {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+    });
+  }
+};