abapgit-agent 1.14.0 → 1.14.2

package/abap/guidelines/branch-workflow.md

@@ -73,10 +73,47 @@ abapgit-agent pull --files src/zcl_auth_handler.clas.abap
 abapgit-agent unit --files src/zcl_auth_handler.clas.testclasses.abap
 
 # 3. Create PR (squash merge enabled on GitHub/GitLab)
-# Go to GitHub and create PR from feature/user-authentication to main
-# Select "Squash and merge" option to combine all commits into one
+# See "Creating a PR" section below for transport handling
 ```
 
+#### Creating a PR
+
+When creating a PR with `gh pr create`:
+
+**Check `.abapgit-agent.json` for `transports.hook`.**
+
+```
+transports.hook present?
+├─ NO  → create PR normally, no transport line needed. STOP here.
+└─ YES → continue below
+```
+
+**If hook is configured — resolve which transport to include:**
+
+```bash
+abapgit-agent transport list --scope task --json
+```
+
+- **One result** → use it directly, no need to ask the user
+- **Multiple results** → show the list to the user and ask which one to use for this PR
+- **No results** → ask the user to provide a transport number manually, or confirm to skip
+
+**Append `transport: <number>` as the last line of the PR body:**
+
+```
+## Summary
+- Implemented user authentication handler
+
+## Changed Objects
+- ZCL_AUTH_HANDLER (CLAS)
+
+transport: DEVK900001
+```
+
+**Why:** The CI pipeline reads this line from the PR description and uses it for the
+Activate stage, overriding the automatic hook selection. This lets the user control
+which transport request receives the activated changes.
+
 #### Why Rebase Before Pull?
 
 ABAP is a **centralized system**. Multiple developers may modify the same files:
@@ -137,5 +174,6 @@ abapgit-agent pull --files src/zcl_auth_handler.clas.abap
 abapgit-agent unit --files src/zcl_auth_handler.clas.testclasses.abap
 git fetch origin main && git rebase origin/main
 git push origin feature/user-authentication --force-with-lease
-# Create PR on GitHub/GitLab (squash 3 commits into 1)
+# Create PR: check transport hook, resolve transport, include in PR body
+# abapgit-agent transport list --scope task --json  → pick transport → append to PR body
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abapgit-agent",
-  "version": "1.14.0",
+  "version": "1.14.2",
   "description": "ABAP Git Agent - Pull and activate ABAP code via abapGit from any git repository",
   "files": [
     "bin/",

package/src/commands/lint.js

@@ -57,7 +57,13 @@ module.exports = {
     }
 
     const cfg = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-    cfg.global.files = abapFiles.map(f => `/${f}`);
+
+    // Scope to changed files + their direct dependencies (interfaces, superclasses)
+    // so abaplint can resolve cross-references without including the whole repo.
+    const abapDir = cfg.global.files.replace(/\/\*\*.*$/, '').replace(/^\//, '') || 'abap';
+    const depFiles = resolveDependencies(abapFiles, abapDir);
+    const allFiles = [...new Set([...abapFiles, ...depFiles])];
+    cfg.global.files = allFiles.map(f => `/${f}`);
 
     const scopedConfig = '.abaplint-local.json';
     fs.writeFileSync(scopedConfig, JSON.stringify(cfg, null, 2));
@@ -117,6 +123,84 @@ function runGit(cmd) {
   }
 }
 
+/**
+ * Resolve direct dependencies of the given ABAP files by scanning their source
+ * for interface/superclass/type references and mapping them to local files.
+ *
+ * Handles:
+ *   INTERFACES <name>.              → <name>.intf.abap + <name>.intf.xml
+ *   INHERITING FROM <name>          → <name>.clas.abap + <name>.clas.xml
+ *   TYPE REF TO <name>              → <name>.intf.abap or <name>.clas.abap (whichever exists)
+ *
+ * Only resolves one level deep — enough for abaplint to check the changed files.
+ * XML companion files are always included alongside their .abap counterpart
+ * so xml_consistency checks can run.
+ */
+function resolveDependencies(abapFiles, abapDir) {
+  const deps    = new Set();
+  const visited = new Set(abapFiles); // don't re-scan changed files as deps
+
+  // Patterns to extract referenced object names from ABAP source
+  const patterns = [
+    /^\s*INTERFACES\s+(\w+)\s*\./gim,
+    /INHERITING\s+FROM\s+(\w+)/gim,
+    /TYPE\s+REF\s+TO\s+(\w+)/gim,
+  ];
+
+  // BFS queue — seed with the changed files, then expand transitively
+  const queue = [...abapFiles];
+
+  while (queue.length > 0) {
+    const file = queue.shift();
+
+    let source;
+    try { source = fs.readFileSync(file, 'utf8'); } catch { continue; }
+
+    for (const pattern of patterns) {
+      pattern.lastIndex = 0;
+      let match;
+      while ((match = pattern.exec(source)) !== null) {
+        const name = match[1].toLowerCase();
+        for (const suffix of [`${name}.intf`, `${name}.clas`]) {
+          const abapFile = path.join(abapDir, `${suffix}.abap`);
+          const xmlFile  = path.join(abapDir, `${suffix}.xml`);
+          if (fs.existsSync(abapFile)) {
+            deps.add(abapFile);
+            if (fs.existsSync(xmlFile)) deps.add(xmlFile);
+            // Recurse into this dep if not yet visited
+            if (!visited.has(abapFile)) {
+              visited.add(abapFile);
+              queue.push(abapFile);
+            }
+            // For interfaces, also include the canonical concrete implementation
+            // (zif_foo → zcl_foo) so rules like unused_variables can fully type-check.
+            if (suffix.endsWith('.intf')) {
+              const implName   = name.replace(/^zif_/, 'zcl_');
+              const implFile   = path.join(abapDir, `${implName}.clas.abap`);
+              const implXml    = path.join(abapDir, `${implName}.clas.xml`);
+              if (fs.existsSync(implFile)) {
+                deps.add(implFile);
+                if (fs.existsSync(implXml)) deps.add(implXml);
+                if (!visited.has(implFile)) {
+                  visited.add(implFile);
+                  queue.push(implFile);
+                }
+              }
+            }
+            break; // intf matched — don't also try clas
+          }
+        }
+      }
+    }
+
+    // Always include the XML companion of each scanned file
+    const xmlCompanion = file.replace(/\.abap$/, '.xml');
+    if (fs.existsSync(xmlCompanion)) deps.add(xmlCompanion);
+  }
+
+  return [...deps];
+}
+
 /**
  * Keep only files that look like ABAP source files
  * (name.type.abap or name.type.subtype.abap).