abapgit-agent 1.14.2 → 1.14.4

package/package.json

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

package/src/commands/lint.js

@@ -61,7 +61,8 @@ module.exports = {
     // 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 fileIndex = buildFileIndex(abapDir);
+    const depFiles = resolveDependencies(abapFiles, fileIndex);
     const allFiles = [...new Set([...abapFiles, ...depFiles])];
     cfg.global.files = allFiles.map(f => `/${f}`);
 
@@ -69,15 +70,40 @@ module.exports = {
     fs.writeFileSync(scopedConfig, JSON.stringify(cfg, null, 2));
 
     // ── Run abaplint ──────────────────────────────────────────────────────────
+    // Dep files are included in the scoped config so abaplint can resolve
+    // cross-references (e.g. implement_methods needs the interface source).
+    // When producing checkstyle output (CI mode), post-filter the XML to only
+    // keep <file> blocks for the originally changed files — suppressing any
+    // pre-existing issues in dependency files that were not part of this change.
     try {
-      const formatArgs = outformat ? `--outformat ${outformat}` : '';
-      const fileArgs   = outfile   ? `--outfile ${outfile}`     : '';
-      const result = spawnSync(
-        `npx @abaplint/cli@latest ${scopedConfig} ${formatArgs} ${fileArgs}`,
-        { stdio: 'inherit', shell: true }
-      );
-      if (result.status !== 0) {
-        process.exitCode = result.status;
+      if (outformat === 'checkstyle') {
+        // Run to a temp file, filter, then write to the final destination.
+        const tempOut = '.abaplint-raw.xml';
+        const abapFilesSet = new Set(abapFiles.map(f => path.resolve(f)));
+        try {
+          const result = spawnSync(
+            `npx @abaplint/cli@latest ${scopedConfig} --outformat checkstyle --outfile ${tempOut}`,
+            { stdio: 'pipe', shell: true }
+          );
+          const raw = fs.existsSync(tempOut) ? fs.readFileSync(tempOut, 'utf8') : '<checkstyle version="8.0"/>';
+          const filtered = filterCheckstyleToFiles(raw, abapFilesSet);
+          if (outfile) {
+            fs.writeFileSync(outfile, filtered);
+          } else {
+            process.stdout.write(filtered);
+          }
+          const issueCount = (filtered.match(/<error /g) || []).length;
+          if (issueCount > 0) process.exitCode = 1;
+        } finally {
+          if (fs.existsSync(tempOut)) fs.unlinkSync(tempOut);
+        }
+      } else {
+        // Interactive: inherit stdio so abaplint's human-readable output flows through.
+        const result = spawnSync(
+          `npx @abaplint/cli@latest ${scopedConfig}`,
+          { stdio: 'inherit', shell: true }
+        );
+        if (result.status !== 0) process.exitCode = result.status;
       }
     } finally {
       fs.unlinkSync(scopedConfig);
@@ -123,6 +149,30 @@ function runGit(cmd) {
   }
 }
 
+/**
+ * Build a map of basename → full path for all .abap and .xml files
+ * found recursively under abapDir. Used for dependency resolution so
+ * that projects with nested folder structures (e.g. src/module/pkg/foo.clas.abap)
+ * are handled correctly — not just flat abap/ layouts.
+ */
+function buildFileIndex(abapDir) {
+  const index = new Map(); // basename (lowercase) → full path
+  function walk(dir) {
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.name.endsWith('.abap') || entry.name.endsWith('.xml')) {
+        index.set(entry.name.toLowerCase(), full);
+      }
+    }
+  }
+  walk(abapDir);
+  return index;
+}
+
 /**
  * Resolve direct dependencies of the given ABAP files by scanning their source
  * for interface/superclass/type references and mapping them to local files.
@@ -132,17 +182,18 @@ function runGit(cmd) {
  *   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.
+ * Uses a filename index built from a recursive walk of abapDir so that
+ * deeply nested project structures are handled correctly.
  * XML companion files are always included alongside their .abap counterpart
  * so xml_consistency checks can run.
  */
-function resolveDependencies(abapFiles, abapDir) {
+function resolveDependencies(abapFiles, fileIndex) {
   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,
+    /^\s*INTERFACES:?\s+(\w+)\s*\./gim,
     /INHERITING\s+FROM\s+(\w+)/gim,
     /TYPE\s+REF\s+TO\s+(\w+)/gim,
   ];
@@ -162,11 +213,11 @@ function resolveDependencies(abapFiles, abapDir) {
       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)) {
+          const abapFile = fileIndex.get(`${suffix}.abap`);
+          const xmlFile  = fileIndex.get(`${suffix}.xml`);
+          if (abapFile) {
             deps.add(abapFile);
-            if (fs.existsSync(xmlFile)) deps.add(xmlFile);
+            if (xmlFile) deps.add(xmlFile);
             // Recurse into this dep if not yet visited
             if (!visited.has(abapFile)) {
               visited.add(abapFile);
@@ -175,12 +226,12 @@ function resolveDependencies(abapFiles, abapDir) {
             // 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)) {
+              const implName  = name.replace(/^zif_/, 'zcl_');
+              const implFile  = fileIndex.get(`${implName}.clas.abap`);
+              const implXml   = fileIndex.get(`${implName}.clas.xml`);
+              if (implFile) {
                 deps.add(implFile);
-                if (fs.existsSync(implXml)) deps.add(implXml);
+                if (implXml) deps.add(implXml);
                 if (!visited.has(implFile)) {
                   visited.add(implFile);
                   queue.push(implFile);
@@ -194,13 +245,38 @@ function resolveDependencies(abapFiles, abapDir) {
     }
 
     // Always include the XML companion of each scanned file
-    const xmlCompanion = file.replace(/\.abap$/, '.xml');
-    if (fs.existsSync(xmlCompanion)) deps.add(xmlCompanion);
+    const xmlBasename = path.basename(file).replace(/\.abap$/, '.xml').toLowerCase();
+    const xmlCompanion = fileIndex.get(xmlBasename);
+    if (xmlCompanion) deps.add(xmlCompanion);
   }
 
   return [...deps];
 }
 
+/**
+ * Filter a checkstyle XML string to only include <file> blocks whose name
+ * attribute resolves to one of the files in the given Set of absolute paths.
+ * The outer <checkstyle> wrapper is preserved; the version attribute is kept.
+ */
+function filterCheckstyleToFiles(xml, abapFilesSet) {
+  // Extract the opening <checkstyle ...> tag (preserves version= attribute).
+  const headerMatch = xml.match(/^[\s\S]*?(<checkstyle[^>]*>)/);
+  const header = headerMatch ? headerMatch[1] : '<checkstyle version="8.0">';
+
+  // Match each <file name="...">...</file> block (including self-closing).
+  const fileBlockRe = /<file\s+name="([^"]*)"[\s\S]*?<\/file>|<file\s+name="([^"]*)"\s*\/>/g;
+  const kept = [];
+  let match;
+  while ((match = fileBlockRe.exec(xml)) !== null) {
+    const filePath = match[1] || match[2];
+    if (abapFilesSet.has(path.resolve(filePath))) {
+      kept.push(match[0]);
+    }
+  }
+
+  return `<?xml version="1.0" encoding="UTF-8"?>\n${header}\n${kept.join('\n')}${kept.length ? '\n' : ''}</checkstyle>\n`;
+}
+
 /**
  * Keep only files that look like ABAP source files
  * (name.type.abap or name.type.subtype.abap).