abapgit-agent 1.15.2 → 1.16.0

package/abap/guidelines/naming-limits.md

@@ -0,0 +1,160 @@
+---
+layout: default
+title: Naming Length Limits
+nav_order: 6
+parent: ABAP Coding Guidelines
+grand_parent: ABAP Development
+---
+
+# ABAP Naming Length Limits
+
+**Searchable keywords**: name length, character limit, 30 characters, 16 characters, 40 characters, too long, truncate, field name, method name, class name, table name, CDS name
+
+> **Rule of thumb**: Most ABAP object names → 30 chars. Table/structure **field names** → 16 chars. CDS/DDLS names → 40 chars. Method names (including test methods) → 30 chars.
+
+---
+
+## Quick Reference
+
+| Object / Element | Max Length |
+|---|---|
+| Class name (CLAS) | **30** |
+| Interface name (INTF) | **30** |
+| Program name (PROG) | **30** |
+| Function Group name (FUGR) | **26** |
+| Function Module name | **30** |
+| Table name (TABL) | **30** |
+| **Table field name** | **16** |
+| Structure name (STRU) | **30** |
+| **Structure field name** | **16** |
+| Data Element name (DTEL) | **30** |
+| Domain name (DOMA) | **30** |
+| Table Type name (TTYP) | **30** |
+| Package name | **30** |
+| **CDS View Entity name (DDLS)** | **40** |
+| CDS Access Control name (DCLS) | **40** |
+| CDS field alias | **30** |
+| Message Class name (MSAG) | **20** |
+| Class method name | **30** |
+| **Test method name** | **30** |
+| Interface method name | **30** |
+| Class attribute name | **30** |
+| Local variable name | **30** |
+| Local type/class name | **30** |
+| Test class name (local) | **30** |
+
+---
+
+## Critical Differences — Don't Confuse These
+
+### Table/Structure Field Names: 16 Characters MAX
+
+This is the **most common mistake**. Field names in TABL and STRU are limited to **16 characters**, not 30.
+
+```xml
+<!-- WRONG — 17 characters -->
+<FIELDNAME>LAST_MODIFIED_AT</FIELDNAME>
+
+<!-- CORRECT — 16 characters or fewer -->
+<FIELDNAME>LAST_MODIFIED</FIELDNAME>
+<FIELDNAME>SYS_CHANGED_AT</FIELDNAME>  <!-- 14 chars ✓ -->
+<FIELDNAME>LAST_PULLED_AT</FIELDNAME>  <!-- 14 chars ✓ -->
+```
+
+When naming table fields, keep names short and descriptive:
+- `CARRID` not `CARRIER_ID_FIELD`
+- `CONNID` not `CONNECTION_IDENTIFIER`
+- `STATUS` not `CURRENT_STATUS_FLAG`
+- `CREATED_AT` not `CREATION_TIMESTAMP`
+
+### CDS View Names: 40 Characters MAX
+
+CDS View Entity (DDLS) names allow up to **40 characters** — more room than regular ABAP objects.
+
+```
+ZC_MY_FLIGHT_BOOKING_REVENUE_SUMMARY     ← 40 chars (at limit)
+ZC_FLIGHT_REVENUE                        ← 17 chars (fine)
+```
+
+However, CDS **field aliases** inside the view are still limited to **30 characters** (ABAP identifier rules).
+
+### Function Group Names: 26 Characters MAX
+
+Function groups (`FUGR`) have a **26-character limit** because ABAP appends a 4-character suffix internally (e.g. `SAPLZMY_FG` prefix + module name). The safe usable name length is 26 characters.
+
+### Test Method Names: 30 Characters MAX — Causes Syntax Error
+
+Test methods (`FOR TESTING`) hit the 30-char limit frequently because the `test_` prefix takes 5 chars before the meaningful content starts.
+
+```abap
+" WRONG — 34 characters → syntax error at activation
+METHODS test_execute_with_minimal_params FOR TESTING.
+
+" CORRECT — abbreviate to stay within 30 chars
+METHODS test_exec_minimal FOR TESTING.     " 18 chars ✓
+METHODS test_exec_with_files FOR TESTING.  " 24 chars ✓
+```
+
+**Counting test method length**: include the full method name — `test_exec_minimal` is 18 characters.
+
+---
+
+## Counting Characters Before You Name Things
+
+Use this mental check before naming any ABAP element:
+
+```
+# Object name: type prefix + your name ≤ limit
+ZCL_             (4 chars) + name ≤ 30  →  name ≤ 26 chars
+ZIF_             (4 chars) + name ≤ 30  →  name ≤ 26 chars
+ZC_              (3 chars) + name ≤ 40  →  name ≤ 37 chars  (CDS)
+Z                (1 char)  + name ≤ 30  →  name ≤ 29 chars  (table/program)
+
+# Project-specific sub-namespace eats more of the budget — plan ahead
+# Example: project uses ZFICO_ prefix for all objects
+ZCL_FICO_        (9 chars) + name ≤ 30  →  name ≤ 21 chars
+ZCL_FICO_PAYMENT_PROPOSAL   = 26 chars  ✓
+ZCL_FICO_PAYMENT_PROPOSAL_V = 27 chars  ✓  (getting tight)
+
+# Field name in TABL/STRU: no prefix, just ≤ 16 total
+PAYMENT_METHOD               = 14 chars  ✓
+PAYMENT_METHOD_CD            = 17 chars  ✗  → shorten to PAYMENT_METH_CD
+
+# Method name: no prefix, just ≤ 30 total
+test_exec_with_files                    →  24 chars ✓
+test_execute_with_minimal_params        →  34 chars ✗
+```
+
+---
+
+## Common Length Violations and Fixes
+
+| Too Long (violates limit) | Fixed Version | Limit |
+|---|---|---|
+| `ZCL_COMMAND_PULL_WITH_RETRY` (30+ chars) | `ZCL_COMMAND_PULL_RETRY` | 30 |
+| `LAST_SUCCESSFULLY_PULLED_AT` (table field, 28 chars) | `LAST_PULLED_AT` | 16 |
+| `test_execute_command_with_files` (test method, 32 chars) | `test_exec_with_files` | 30 |
+| `ZC_MY_VERY_LONG_CDS_VIEW_NAME_EXCEEDS_40_CHARS` (47 chars) | `ZC_MY_LONG_CDS_VIEW_NAME_TRIMMED` | 40 |
+| `ZBIZ_OBJECT_CREATION_SERVICE_MESSAGE_CLASS` (MSAG, 43 chars) | `ZBIZ_CREATE_MSGS` | 20 |
+
+---
+
+## SAP Technical Basis for These Limits
+
+These limits come from the ABAP Dictionary (DDIC) and ABAP kernel:
+
+| Limit Source | Explanation |
+|---|---|
+| 30 chars (most objects) | ABAP uses `RSYN` program name space; objects stored in `TADIR` with `SOBJ_NAME CHAR(40)` but compiler enforces 30 for classes/interfaces/programs |
+| 16 chars (DDIC fields) | Stored in `DD03L.FIELDNAME CHAR(16)` — this is a hard database column width |
+| 40 chars (CDS names) | CDS objects stored in `DD02L.TABNAME CHAR(40)` — intentionally larger for CDS |
+| 20 chars (MSAG) | Message class name stored in `T100A.ARBGB CHAR(20)` |
+| 26 chars (FUGR) | Function group internally prefixed with `SAPL` (4 chars) for the main include |
+
+---
+
+## See Also
+
+- **Naming Conventions** (objects.md) — prefixes per object type
+- **Object Creation** (object-creation.md) — which files to create
+- **Testing** (testing.md) — test method naming (30-char limit detail)

package/abap/guidelines/object-creation.md

@@ -24,7 +24,7 @@ Replace `<name>` with the actual object name from this project's naming conventi
 | CDS Access Control (DCLS) | `<name>.dcls.asdcls` | `<name>.dcls.xml` | `ref --topic abapgit` |
 | Function Group (FUGR) | `<name>.fugr.abap` + includes | `<name>.fugr.xml` | `ref --topic abapgit` |
 | Table (TABL) | *(none — XML-only)* | `<name>.tabl.xml` | `ref --topic abapgit-xml-only` |
-| Structure (STRU) | *(none — XML-only)* | `<name>.stru.xml` | `ref --topic abapgit-xml-only` |
+| Structure (STRU) | *(none — XML-only)* | `<name>.tabl.xml` ⚠️ NOT `.stru.xml` | `ref --topic abapgit-xml-only` |
 | Data Element (DTEL) | *(none — XML-only)* | `<name>.dtel.xml` | `ref --topic abapgit-xml-only` |
 | Table Type (TTYP) | *(none — XML-only)* | `<name>.ttyp.xml` | `ref --topic abapgit-xml-only` |
 | Domain (DOMA) | *(none — XML-only)* | `<name>.doma.xml` | `ref --topic abapgit-xml-only` |

package/abap/guidelines/objects.md

@@ -15,12 +15,13 @@ grand_parent: ABAP Development
 | | SAP Namespace | Customer Namespace |
 |---|---|---|
 | **Object prefix** | `CL_*`, `IF_*`, `/NAME/CL_*`, `/NAME/IF_*`, etc. | `Z*`, `Y*` |
-| **Package prefix** | SAP-delivered (e.g. `SFIN`, `CA_*`, `/NAME/*`) | `Z*`, `Y*`, `$*` |
+| **Package prefix** | SAP-delivered (e.g. `SFIN`, `CA_*`, `/NAME/*`) | `Z*`, `Y*`, `$*` (local/non-transportable) |
 | **Ownership** | Delivered and maintained by SAP | Owned by the customer |
 | **In git repo** | Objects from an SAP-delivered package | Custom development objects |
 
 > **Rule**: Never add customer-created objects (including PoC/probe classes) into SAP namespace
 > packages. PoC objects always use `Z*`/`Y*` prefix and always go in a `Z*`, `Y*`, or `$*` package
+> (use `$*` only for throwaway probes — non-transportable)
 > — even on a project where production objects use SAP namespace.
 
 ## How to Determine This Project's Naming Convention
@@ -43,7 +44,8 @@ Applied when no `objects.local.md` exists:
 | Class | `ZCL_` | `ZCL_MY_CLASS` |
 | Interface | `ZIF_` | `ZIF_MY_INTERFACE` |
 | Program | `Z` | `ZMY_PROGRAM` |
-| Package | `$` | `$MY_PACKAGE` |
+| Package | `Z` or `Y` | `ZMYPROJECT` |
+> **Note**: `$` packages (e.g. `$TMP`) are local/non-transportable — use only for throwaway probe objects, never for real development.
 | Table | `Z` | `ZMY_TABLE` |
 | CDS View Entity | `ZC_` | `ZC_MY_VIEW` |
 | Data Element | `Z` | `ZMY_ELEMENT` |
@@ -83,3 +85,4 @@ Default package:  /MYNAMESPACE/MAIN
 
 → For file structure (what files to create): `abapgit-agent ref --topic object-creation`
 → For XML templates: `abapgit-agent ref --topic abapgit`
+→ For name **length limits** (30/16/40 char rules): `abapgit-agent ref --topic naming-limits`

package/abap/guidelines/string-template.md

@@ -0,0 +1,84 @@
+---
+layout: default
+title: String Templates
+nav_order: 25
+parent: ABAP Coding Guidelines
+grand_parent: ABAP Development
+---
+
+# String Templates
+
+**Searchable keywords**: string template, pipe, `|...|`, literal brace, escape, expression limiter, JSON, `\{`, `\}`
+
+## Syntax
+
+String templates are delimited by `|...|`. Embedded expressions use `{ expr }`:
+
+```abap
+DATA(s) = |Hello { lv_name }!|.
+DATA(s) = |User: { cl_abap_context_info=>get_user_technical_name( ) }|.
+DATA(s) = |Length: { strlen( lv_text ) }|.
+```
+
+## Escaping Special Characters
+
+Inside `|...|`, four characters have special meaning and must be escaped with `\`:
+
+| Character | Escape as | Produces |
+|-----------|-----------|---------|
+| `{`       | `\{`      | literal `{` |
+| `}`       | `\}`      | literal `}` |
+| `\`       | `\\`      | literal `\` |
+| `\|`      | `\|`      | literal `\|` |
+
+```abap
+" Produces: \ | { }
+DATA(s) = |\\ \| \{ \}|.
+```
+
+## JSON Payloads — The Most Common Mistake
+
+JSON objects start with `{` — which ABAP treats as an expression delimiter.
+**Always escape outer JSON braces as `\{` and `\}`.**
+
+```abap
+" WRONG — "Expression limiter '{' in string template not followed by space"
+rv_result = |{"success":"X","name":"{ lv_name }"}|.
+"            ^ unescaped { triggers parse error
+
+" CORRECT — outer JSON braces escaped, expression { } left as-is
+rv_result = |\{"success":"X","name":"{ lv_name }"\}|.
+
+" CORRECT — error with method call
+rv_result = |\{"success":"","error":"{ lx_error->get_text( ) }"\}|.
+
+" CORRECT — multiple embedded fields
+rv_result = |\{"success":"X","object":"{ lv_obj_name }","type":"{ lv_obj_type }"\}|.
+```
+
+## Control Characters
+
+```abap
+DATA(s) = |line1\nline2|.   " newline
+DATA(s) = |col1\tcol2|.     " tab
+DATA(s) = |line1\r\nline2|. " CR+LF
+```
+
+## Chaining with `&&`
+
+```abap
+DATA(s) = |{ lv_a }| && ` separator ` && |{ lv_b }|.
+```
+
+## Performance Note
+
+A string template containing only literal text (no `{ }` expressions) is evaluated at
+runtime. Prefer backquote literals for pure text:
+
+```abap
+" Prefer this for literal-only strings
+DATA(s) = `Hello World`.
+
+" Not this (runtime overhead with no benefit)
+DATA(s) = |Hello World|.
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abapgit-agent",
-  "version": "1.15.2",
+  "version": "1.16.0",
   "description": "ABAP Git Agent - Pull and activate ABAP code via abapGit from any git repository",
   "files": [
     "bin/",
@@ -36,6 +36,7 @@
     "test:cmd:preview": "node tests/run-all.js --cmd --command=preview",
     "test:cmd:tree": "node tests/run-all.js --cmd --command=tree",
     "test:cmd:dump": "node tests/run-all.js --cmd --command=dump",
+    "test:drop": "node tests/run-all.js --drop",
     "test:cmd:debug": "node tests/run-all.js --cmd --command=debug",
     "test:debug": "node tests/run-all.js --debug",
     "test:debug:scenarios": "bash tests/integration/debug-scenarios.sh",

package/src/commands/drop.js

@@ -0,0 +1,171 @@
+/**
+ * Drop command - Physically delete a single ABAP object from the ABAP system
+ */
+
+const { printHttpError } = require('../utils/format-error');
+
+// Map file extension (second-to-last part) to ABAP object type label
+const EXT_TO_TYPE = {
+  clas: 'CLAS', intf: 'INTF', prog: 'PROG', fugr: 'FUGR',
+  tabl: 'TABL', dtel: 'DTEL', ttyp: 'TTYP', doma: 'DOMA',
+  ddls: 'DDLS', dcls: 'DCLS', msag: 'MSAG', stru: 'STRU'
+};
+
+/**
+ * Derive a display label for the object from the file path.
+ * e.g. "abap/zcl_foo.clas.abap" → { name: "ZCL_FOO", type: "CLAS" }
+ */
+function objectFromFile(filePath) {
+  const base = filePath.split('/').pop();
+  const parts = base.split('.');
+  if (parts.length < 3) return null;
+  const name = parts[0].toUpperCase();
+  const typeExt = parts[1].toLowerCase();
+  const type = EXT_TO_TYPE[typeExt] || typeExt.toUpperCase();
+  return { name, type };
+}
+
+module.exports = {
+  name: 'drop',
+  description: 'Physically delete a single ABAP object from the ABAP system',
+  requiresAbapConfig: true,
+  requiresVersionCheck: true,
+
+  async execute(args, context) {
+    const { loadConfig, AbapHttp, gitUtils, getTransport, getConflictSettings } = context;
+
+    // Show help if requested
+    if (args.includes('--help') || args.includes('-h')) {
+      console.log(`
+Usage:
+  abapgit-agent drop --files <file>
+  abapgit-agent drop --files <file> --transport <TRANSPORT>
+  abapgit-agent drop --files <file> --pull
+
+Description:
+  Physically deletes a single ABAP object from the ABAP system using abapGit's
+  own object serializer. The object type and name are derived from the file path.
+
+  Use --pull to immediately re-activate the object from git after deletion
+  (useful to force a clean re-installation).
+
+Parameters:
+  --files <file>          Path to the ABAP source or XML file (required).
+                          Accepted extensions: .abap, .asddls, .tabl.xml, etc.
+                          The file must exist on disk.
+  --transport <TRANSPORT> Transport request (e.g. DEVK900001). Optional.
+  --pull                  Re-activate the object via pull after deletion.
+  --conflict-mode <mode>  Conflict mode for --pull: abort (default) or ignore.
+
+Examples:
+  abapgit-agent drop --files abap/zcl_foo.clas.abap
+  abapgit-agent drop --files abap/zcl_foo.clas.abap --pull
+  abapgit-agent drop --files abap/zmy_table.tabl.xml --transport DEVK900001
+`);
+      return;
+    }
+
+    const filesArgIndex = args.indexOf('--files');
+    const transportArgIndex = args.indexOf('--transport');
+    const conflictModeArgIndex = args.indexOf('--conflict-mode');
+    const doPull = args.includes('--pull');
+
+    if (filesArgIndex === -1 || filesArgIndex + 1 >= args.length) {
+      console.error('❌ Error: --files is required');
+      console.error('   Usage: abapgit-agent drop --files <file>');
+      process.exit(1);
+    }
+
+    const filePath = args[filesArgIndex + 1].trim();
+
+    // Validate file exists on disk
+    const fs = require('fs');
+    if (!fs.existsSync(filePath)) {
+      console.error(`❌ Error: file not found: ${filePath}`);
+      process.exit(1);
+    }
+
+    // Validate file extension (same rules as pull --files)
+    const base = filePath.split('/').pop();
+    const parts = base.split('.');
+    const lastExt = parts[parts.length - 1].toLowerCase();
+    const ABAP_SOURCE_EXTS = new Set(['abap', 'asddls']);
+    const isXmlOnlyObject = parts.length === 3 && parts[0].length > 0 && lastExt === 'xml';
+    if (!ABAP_SOURCE_EXTS.has(lastExt) && !isXmlOnlyObject) {
+      console.error('❌ Error: --files must be an ABAP source file (.abap, .asddls) or an XML-only object file (name.type.xml).');
+      process.exit(1);
+    }
+
+    const obj = objectFromFile(filePath);
+
+    if (obj && obj.type === 'DTEL') {
+      console.error(`❌ drop does not support DTEL objects.`);
+      console.error(`   Data elements cannot be re-activated after deletion due to SAP CBDA`);
+      console.error(`   activation engine limitations. Edit the XML file and run pull instead.`);
+      process.exit(1);
+    }
+
+    const transportRequest = transportArgIndex !== -1 ? args[transportArgIndex + 1] : (getTransport ? getTransport() : null);
+    const conflictMode = conflictModeArgIndex !== -1 ? args[conflictModeArgIndex + 1] : (getConflictSettings ? getConflictSettings().mode : 'abort');
+
+    console.log(`\n🗑️  Dropping ${obj ? obj.type + ' ' + obj.name : filePath} from ABAP system...`);
+    if (transportRequest) {
+      console.log(`   Transport: ${transportRequest}`);
+    }
+
+    const config = loadConfig();
+    const http = new AbapHttp(config);
+
+    try {
+      const csrfToken = await http.fetchCsrfToken();
+
+      const data = { file: filePath };
+      if (transportRequest) {
+        data.transport_request = transportRequest;
+      }
+
+      const result = await http.post('/sap/bc/z_abapgit_agent/drop', data, { csrfToken });
+
+      const success = result.SUCCESS || result.success;
+      const objectName = result.OBJECT || result.object;
+      const objectType = result.TYPE || result.type;
+      const message = result.MESSAGE || result.message;
+      const error = result.ERROR || result.error;
+
+      if (success === 'X' || success === true) {
+        console.log(`✅ Object deleted successfully.`);
+        if (objectName && objectType) {
+          console.log(`   Object: ${objectName} (${objectType})`);
+        }
+      } else {
+        console.error(`❌ Failed to delete object`);
+        console.error(`   Error: ${error || message || 'Unknown error'}`);
+        process.exit(1);
+      }
+    } catch (error) {
+      printHttpError(error, {});
+      process.exit(1);
+    }
+
+    // --pull: re-activate the object from git
+    if (doPull) {
+      console.log(`\n↩️  Re-pulling from git...`);
+      const pullCommand = require('./pull');
+      const gitUrl = gitUtils.getRemoteUrl();
+      const branch = gitUtils.getBranch();
+      if (!gitUrl) {
+        console.error('❌ Cannot re-pull: no git remote configured.');
+        process.exit(1);
+      }
+      try {
+        await pullCommand.pull(
+          gitUrl, branch, [filePath], transportRequest || null,
+          loadConfig, AbapHttp, false, undefined, conflictMode, false, false
+        );
+      } catch (pullError) {
+        // pull() already printed the error
+        process.exit(1);
+      }
+    }
+  }
+};

package/src/commands/index.js

@@ -30,5 +30,6 @@ module.exports = {
   pull:      require('./pull'),
   upgrade:   require('./upgrade'),
   transport: require('./transport'),
-  lint:      require('./lint')
+  lint:      require('./lint'),
+  drop:      require('./drop')
 };

package/src/commands/syntax.js

@@ -48,6 +48,7 @@ module.exports = {
     // Build objects array from files
     // Group class files together (main + locals)
     const classFilesMap = new Map(); // className -> { main, locals_def, locals_imp }
+    const fugrGroupMap = new Map();  // groupName -> { dir, fmFiles: Map<fmName, source> }
     const objects = [];
 
     for (const file of syntaxFiles) {
@@ -83,6 +84,35 @@ module.exports = {
         objType = 'DDLS';
         objName = baseName.split('.')[0].toUpperCase();
         fileKind = 'main';
+      } else if (baseName.includes('.fugr.')) {
+        objType = 'FUGR';
+        const parts = baseName.split('.');   // e.g. ['zmy_fugr', 'fugr', 'zmy_my_function', 'abap']
+        objName = parts[0].toUpperCase();    // group name e.g. 'ZMY_FUGR'
+        const includeFile = parts[2] || ''; // e.g. 'zmy_my_function', 'lzmy_fugrtop', 'saplzmy_fugr'
+        const groupLower = parts[0].toLowerCase();
+        const isTopInclude = new RegExp(`^l${groupLower}top$`, 'i').test(includeFile);
+        const isUInclude   = new RegExp(`^l${groupLower}u\\d+$`, 'i').test(includeFile);
+        const isSapl       = includeFile.toLowerCase().startsWith('sapl');
+        const isFm = !isTopInclude && !isUInclude && !isSapl && includeFile !== '';
+
+        // Read source and store in fugrGroupMap
+        const filePath = pathModule.resolve(file);
+        if (!fs.existsSync(filePath)) {
+          console.error(`  Error: File not found: ${file}`);
+          continue;
+        }
+        const source = fs.readFileSync(filePath, 'utf8');
+        const dir = pathModule.dirname(filePath);
+
+        if (!fugrGroupMap.has(objName)) {
+          fugrGroupMap.set(objName, { dir, fmFiles: new Map() });
+        }
+        if (isFm) {
+          const fmName = includeFile.toUpperCase();
+          fugrGroupMap.get(objName).fmFiles.set(fmName, source);
+        }
+        // Skip adding to objects here — handled after auto-detection below
+        continue;
       }
 
       // Read source from file
@@ -236,12 +266,74 @@ module.exports = {
       }
     }
 
+    // Helper: read FIXPT from SAPL XML for a function group
+    function readFugrFixpt(dir, groupName) {
+      const xmlFile = pathModule.join(dir, `${groupName.toLowerCase()}.fugr.sapl${groupName.toLowerCase()}.xml`);
+      if (fs.existsSync(xmlFile)) {
+        const xmlContent = fs.readFileSync(xmlFile, 'utf8');
+        const fixptMatch = xmlContent.match(/<FIXPT>([^<]+)<\/FIXPT>/);
+        if (fixptMatch && fixptMatch[1] === 'X') return 'X';
+      }
+      return '';
+    }
+
+    // Helper: classify a FUGR include filename — returns fm name (uppercase) or null if not an FM file
+    function getFugrFmName(includeFile, groupLower) {
+      if (!includeFile) return null;
+      const isTopInclude = new RegExp(`^l${groupLower}top$`, 'i').test(includeFile);
+      const isUInclude   = new RegExp(`^l${groupLower}u\\d+$`, 'i').test(includeFile);
+      const isSapl       = includeFile.toLowerCase().startsWith('sapl');
+      if (isTopInclude || isUInclude || isSapl) return null;
+      return includeFile.toUpperCase();
+    }
+
+    // Auto-detect all FM files for each function group and build objects
+    for (const [groupName, groupData] of fugrGroupMap) {
+      const { dir } = groupData;
+      const groupLower = groupName.toLowerCase();
+      const prefix = `${groupLower}.fugr.`;
+
+      // Scan directory for all FUGR files belonging to this group
+      let allFiles;
+      try {
+        allFiles = fs.readdirSync(dir);
+      } catch (e) {
+        allFiles = [];
+      }
+      for (const f of allFiles) {
+        if (!f.toLowerCase().startsWith(prefix) || !f.toLowerCase().endsWith('.abap')) continue;
+        const parts = f.split('.');
+        const includeFile = parts[2] || '';
+        const fmName = getFugrFmName(includeFile, groupLower);
+        if (fmName && !groupData.fmFiles.has(fmName)) {
+          groupData.fmFiles.set(fmName, fs.readFileSync(pathModule.join(dir, f), 'utf8'));
+          if (!jsonOutput) console.log(`  Auto-detected: ${f}`);
+        }
+      }
+
+      if (groupData.fmFiles.size === 0) {
+        if (!jsonOutput) console.error(`  Warning: No FM source files found for FUGR ${groupName}`);
+        continue;
+      }
+
+      const fixpt = readFugrFixpt(dir, groupName);
+
+      // Add one object per FM
+      for (const [fmName, source] of groupData.fmFiles) {
+        objects.push({
+          type: 'FUGR',
+          name: groupName,
+          source: source,
+          fugr_include_name: fmName,
+          fixpt: fixpt
+        });
+      }
+    }
+
     if (objects.length === 0) {
       console.error('  No valid files to check');
       process.exit(1);
     }
-
-    // Send request
     const data = {
       objects: objects,
       uccheck: cloudMode ? '5' : 'X'
@@ -258,7 +350,8 @@ module.exports = {
       console.log(JSON.stringify(result, null, 2));
     } else {
       // Display results for each object
-      for (const res of results) {
+      for (let i = 0; i < results.length; i++) {
+        const res = results[i];
         const objSuccess = res.SUCCESS !== undefined ? res.SUCCESS : res.success;
         const objType = res.OBJECT_TYPE || res.object_type || 'UNKNOWN';
         const objName = res.OBJECT_NAME || res.object_name || 'UNKNOWN';
@@ -267,13 +360,18 @@ module.exports = {
         const warnings = res.WARNINGS || res.warnings || [];
         const objMessage = res.MESSAGE || res.message || '';
 
+        // For FUGR: show which FM was checked alongside the group name
+        const sentObj = objects[i] || {};
+        const fugrFmLabel = (objType === 'FUGR' && sentObj.fugr_include_name)
+          ? ` (${sentObj.fugr_include_name})` : '';
+
         if (objSuccess) {
-          console.log(`✅ ${objType} ${objName} - Syntax check passed`);
+          console.log(`✅ ${objType} ${objName}${fugrFmLabel} - Syntax check passed`);
           if (warnings.length > 0) {
             console.log(`   (${warnings.length} warning(s))`);
           }
         } else {
-          console.log(`❌ ${objType} ${objName} - Syntax check failed (${errorCount} error(s))`);
+          console.log(`❌ ${objType} ${objName}${fugrFmLabel} - Syntax check failed (${errorCount} error(s))`);
           console.log('');
           console.log('Errors:');
           console.log('─'.repeat(60));
@@ -287,19 +385,25 @@ module.exports = {
 
             // Display which file/include the error is in
             if (include) {
-              const includeMap = {
-                'main': { display: 'Main class', suffix: '.clas.abap' },
-                'locals_def': { display: 'Local definitions', suffix: '.clas.locals_def.abap' },
-                'locals_imp': { display: 'Local implementations', suffix: '.clas.locals_imp.abap' },
-                'testclasses': { display: 'Test classes', suffix: '.clas.testclasses.abap' }
-              };
-              const includeInfo = includeMap[include] || { display: include, suffix: '' };
-
-              // Show both display name and filename
-              if (includeInfo.suffix) {
-                console.log(`  In: ${includeInfo.display} (${objName.toLowerCase()}${includeInfo.suffix})`);
+              // For FUGR: include = lowercase FM name → display as '<group>.fugr.<fm_name>.abap'
+              if (objType === 'FUGR') {
+                const fugrFile = `${objName.toLowerCase()}.fugr.${include}.abap`;
+                console.log(`  In: Function module ${include.toUpperCase()} (${fugrFile})`);
               } else {
-                console.log(`  In: ${includeInfo.display}`);
+                const includeMap = {
+                  'main': { display: 'Main class', suffix: '.clas.abap' },
+                  'locals_def': { display: 'Local definitions', suffix: '.clas.locals_def.abap' },
+                  'locals_imp': { display: 'Local implementations', suffix: '.clas.locals_imp.abap' },
+                  'testclasses': { display: 'Test classes', suffix: '.clas.testclasses.abap' }
+                };
+                const includeInfo = includeMap[include] || { display: include, suffix: '' };
+
+                // Show both display name and filename
+                if (includeInfo.suffix) {
+                  console.log(`  In: ${includeInfo.display} (${objName.toLowerCase()}${includeInfo.suffix})`);
+                } else {
+                  console.log(`  In: ${includeInfo.display}`);
+                }
               }
             }
             if (methodName) {