abapgit-agent 1.15.3 → 1.16.0

package/abap/CLAUDE.md

@@ -179,26 +179,27 @@ Anything else (SAP namespace object, or SAP-delivered package)?
 
 ---
 
-### 4. Use Syntax Command Before Commit (for CLAS, INTF, PROG, DDLS)
+### 4. Use Syntax Command Before Commit (for CLAS, INTF, PROG, DDLS, FUGR)
 
 ```
 ❌ WRONG: Make changes → Commit → Push → Pull → Find errors → Fix → Repeat
 ✅ CORRECT: Make changes → Run syntax → Fix locally → Commit → Push → Pull → Done
 ```
 
-**For CLAS, INTF, PROG, DDLS files**: Run `syntax` command BEFORE commit to catch errors early.
+**For CLAS, INTF, PROG, DDLS, FUGR files**: Run `syntax` command BEFORE commit to catch errors early.
 
 ```bash
 # Check syntax of local code (no commit/push needed)
 # Use the actual filename from your project (name comes from objects.local.md)
 abapgit-agent syntax --files src/<name>.clas.abap
 abapgit-agent syntax --files src/<name>.ddls.asddls
+abapgit-agent syntax --files src/<name>.fugr.<fm_name>.abap
 
 # Check multiple INDEPENDENT files
 abapgit-agent syntax --files src/<name1>.clas.abap,src/<name2>.clas.abap
 ```
 
-**For other types (FUGR, TABL, etc.)**: Skip syntax, proceed to commit/push/pull.
+**For other types (TABL, STRU, DCLS, etc.)**: Skip syntax, proceed to commit/push/pull.
 
 **Why use syntax command?**
 - Catches syntax errors BEFORE polluting git history with fix commits
@@ -424,7 +425,39 @@ After activating a class, stop and tell the user: `"Class is activated. Run with
 
 ---
 
-### 10. Probe and PoC Objects — Always Z/Y, Never in SAP Packages
+### 10. Never Run `drop` Command Without Explicit Permission
+
+**Never call `abapgit-agent drop` unless the user explicitly confirms.** Dropping an object physically deletes it from the ABAP system — this is irreversible without a subsequent pull.
+
+**When to SUGGEST `drop --pull`:**
+
+When an object is in a broken or inconsistent state that cannot be resolved by re-pulling:
+- `inspect` reports **"INCLUDE report ... not found"** (stale include in ABAP not present in git)
+- Pull repeatedly fails with **"Activation cancelled"** and re-pulling doesn't fix it
+- Object has a corrupt inactive version that permanently blocks activation
+
+In these cases, suggest the fix and wait for confirmation:
+
+```
+"The object ZCL_FOO has an inconsistent state (stale include in ABAP).
+ This can be fixed by dropping and re-pulling it:
+
+   abapgit-agent drop --files abap/zcl_foo.clas.abap --pull
+
+ This will delete ZCL_FOO from ABAP and immediately re-activate it from git.
+ Confirm when ready."
+```
+
+**What `drop --pull` does:**
+1. Physically deletes the object from the ABAP system
+2. Immediately re-pulls and re-activates it from git (clean state)
+3. Does NOT touch the git repository file
+
+**Constraint:** Only CLAS, INTF, PROG, TABL, TTYP are supported. DTEL (data elements) are rejected — edit the XML and use `pull` instead.
+
+---
+
+### 11. Probe and PoC Objects — Always Z/Y, Never in SAP Packages
 
 ```
 ❌ WRONG: Create a probe/PoC object with the project's SAP namespace prefix
@@ -450,7 +483,7 @@ Never assume — wait for the user's answer before proceeding.
 
 ---
 
-### 11. Troubleshooting ABAP Issues
+### 12. Troubleshooting ABAP Issues
 
 | Symptom | Tool | When |
 |---|---|---|
@@ -722,18 +755,18 @@ abapgit-agent pull --files src/<name>.clas.abap --sync-xml
 
 ```
 Modified ABAP files?
-├─ CLAS/INTF/PROG/DDLS files?
+├─ CLAS/INTF/PROG/DDLS/FUGR files?
 │  ├─ Independent files (no cross-dependencies)?
 │  │  └─ ✅ Use: syntax → [abaplint] → commit → push → pull --sync-xml
 │  └─ Dependent files (interface + class, class uses class)?
 │     └─ ✅ Use: skip syntax → [abaplint] → commit → push → pull --sync-xml
-└─ Other types (FUGR, TABL, STRU, DTEL, TTYP, etc.)?
+└─ Other types (TABL, STRU, DTEL, TTYP, etc.)?
    ├─ XML-only objects (TABL, STRU, DTEL, TTYP, DOMA, MSAG)?
    │  └─ ✅ Use: skip syntax → [abaplint] → commit → push → pull --files abap/ztable.tabl.xml --sync-xml
    ├─ DCLS (CDS access control)?
    │  └─ ✅ Use: skip syntax → [abaplint] → commit → push → pull --files abap/zc_view.dcls.xml --sync-xml
    │         ⚠️  Pass the .xml file — pull --files does NOT accept .asdcls extensions
-   └─ FUGR and other complex objects?
+   └─ Other complex objects?
       └─ ✅ Use: skip syntax → [abaplint] → commit → push → pull --sync-xml → (if errors: inspect)
 
 [abaplint] = run abapgit-agent lint only if .abaplint.json exists in repo root
@@ -761,6 +794,7 @@ Modified ABAP files?
 | `ref --topic cds-testing` | CDS Testing (Test Double Framework) |
 | `ref --topic json` | JSON Handling |
 | `ref --topic common-errors` | Common ABAP Errors - Quick Fixes |
+| `ref --topic string-template` | String Templates — syntax, escaping `\{` `\}`, JSON payloads |
 | `ref --topic abapgit` | abapGit XML Metadata — **use for CDS/DDLS XML**, also CLAS, INTF, PROG, DCLS, FUGR |
 | `ref --topic abapgit-xml-only` | abapGit XML Metadata — XML-only objects (TABL, STRU, DTEL, TTYP, DOMA, MSAG) |
 | `ref --topic abapgit-fugr` | abapGit XML Metadata — Function Group (FUGR) details |

package/abap/guidelines/abaplint.md

@@ -80,6 +80,41 @@ lv_response = lv_response && '"key":"val"}'.
 | `DATA(lv) = 'literal'.` followed by `&&` | ❌ | Infers `C LENGTH N`, truncates |
 | `DATA(lv) = 'literal'.` used only in `\|{ lv }\|` | ⚠️ | Technically works but misleading — prefer explicit type |
 | `DATA(lv) = 'X'.` used as abap_bool flag | ✅ | `C LENGTH 1` is correct for flags |
+| `DATA(lv) = COND string( WHEN ... THEN str+off ELSE str ).` | ❌ | Offset notation on `string` inside COND raises `CX_SY_RANGE_OUT_OF_BOUNDS` at runtime |
+
+### The offset-notation-in-COND trap
+
+Offset/length notation (`str+off` or `str(len)`) on a `string`-typed variable **cannot appear
+as a result expression inside `COND`** — even when the `COND` is explicitly typed as `string`.
+ABAP evaluates both branch types at generation time and the offset expression on a dynamic
+string is invalid, causing a `CX_SY_RANGE_OUT_OF_BOUNDS` crash at runtime.
+
+```abap
+DATA lv_file TYPE string VALUE 'src/foo.clas.abap'.
+DATA(lv_pos) = find( val = lv_file sub = '/' occ = -1 ).
+
+* WRONG — CX_SY_RANGE_OUT_OF_BOUNDS at runtime
+DATA(lv_path) = COND string(
+  WHEN lv_pos > 0 THEN '/' && lv_file(lv_pos + 1)   " ← offset on string = crash
+  ELSE '/' ).
+
+* CORRECT — use substring() which returns string and is safe in COND
+DATA(lv_path) = COND string(
+  WHEN lv_pos > 0 THEN '/' && substring( val = lv_file len = lv_pos + 1 )
+  ELSE '/' ).
+
+* ALSO CORRECT — keep IF/ELSE with DATA x TYPE string
+DATA lv_path TYPE string.
+IF lv_pos > 0.
+  DATA(lv_len) = lv_pos + 1.
+  lv_path = '/' && lv_file(lv_len).
+ELSE.
+  lv_path = '/'.
+ENDIF.
+```
+
+**Rule**: whenever the prefer_inline quickfix would produce `COND ... THEN str+off` or
+`COND ... THEN str(len)`, use `substring()` instead, or keep the `IF/ELSE` form.
 
 ### Rule of thumb
 

package/abap/guidelines/common-errors.md

@@ -8,7 +8,7 @@ grand_parent: ABAP Development
 
 # Common ABAP Errors - Quick Fixes
 
-**Searchable keywords**: error, syntax error, field mismatch, fixed point, comma, host variable, @ prefix, type incompatible
+**Searchable keywords**: error, syntax error, field mismatch, fixed point, comma, host variable, @ prefix, type incompatible, string template, expression limiter, literal brace, http 500, xml metadata mismatch, interface description, descript, recompilation, offset notation, cond trap, cx_sy_range_out_of_bounds
 
 ## Fixed Point Arithmetic Error
 
@@ -119,6 +119,83 @@ or declare the variable explicitly with `TYPE string`.
 
 ---
 
+## Offset Notation on String in COND — CX_SY_RANGE_OUT_OF_BOUNDS
+
+**Symptom**: Pull succeeds but ABAP crashes at runtime with `CX_SY_RANGE_OUT_OF_BOUNDS`
+inside a method using `COND`.
+
+**Root cause**: Offset/length notation on a `string` variable (`str+off`, `str(len)`)
+**cannot be used as a result expression inside `COND`** — even with an explicit `COND string(...)` type.
+The abaplint `prefer_inline` quickfix can introduce this automatically when converting
+an `IF/ELSE` block that assigns from a string-variable offset.
+
+```abap
+* WRONG — crashes at runtime with CX_SY_RANGE_OUT_OF_BOUNDS
+DATA(lv_path) = COND string(
+  WHEN lv_pos > 0 THEN '/' && lv_file(lv_pos + 1)   " ← string offset in COND
+  ELSE '/' ).
+
+* CORRECT — use substring() instead
+DATA(lv_path) = COND string(
+  WHEN lv_pos > 0 THEN '/' && substring( val = lv_file len = lv_pos + 1 )
+  ELSE '/' ).
+```
+
+**Fix**: Replace `str+off` / `str(len)` inside `COND` results with `substring( val = str off = off )` or
+`substring( val = str len = len )`, or revert to the `IF/ELSE` form with `DATA x TYPE string`.
+
+→ See `abaplint.md` for the full safe/unsafe table for `prefer_inline`.
+
+---
+
+## XML Metadata Mismatch — HTTP 500 on Pull
+
+**Symptom**: `pull` returns HTTP 500 with no short dump (ST22) for the request user.
+Other objects pull fine; only a specific interface or class fails.
+
+**Root cause**: The `.intf.xml` or `.clas.xml` file in git has a metadata field (e.g. `DESCRIPT`,
+`UNICODE`, `STATE`) that differs from the active ABAP system value. abapGit writes the git
+value back to VSEOINTERF/VSEOCLASS, which forces the SAP class framework to recompile all
+implementing/inheriting objects. If any implementing class has a syntax or generation
+issue with the current active source, the recompilation crashes outside the normal exception
+handler — producing HTTP 500 with no dump.
+
+**Diagnosis**:
+1. No dump in ST22 for your user → not a user-code crash
+2. Only one specific INTF/CLAS fails → metadata delta in its XML triggers recompilation
+3. Check what differs: `abapgit-agent view --objects ZIF_MY_INTF --type INTF` and compare
+   `DESCRIPT` / other fields with the XML file in git
+
+**Fix**: Sync the XML to match the ABAP system value. The easiest way:
+
+```bash
+# Pull without --sync-xml first to let abapGit rewrite the XML from the system
+abapgit-agent pull --files abap/zif_my_intf.intf.abap --sync-xml
+```
+
+Or manually correct the field in the XML file to match the system value, then push and pull.
+
+**Prevention**: Always use `--sync-xml` after pulling new objects so the XML stays in sync
+with what the ABAP serializer produces.
+
+---
+
+**Error**: `Expression limiter '{' in string template not followed by space`
+
+Literal `{` and `}` (e.g. in JSON payloads) must be escaped as `\{` and `\}` inside `|...|`.
+
+```abap
+" WRONG — unescaped { in JSON triggers parse error
+rv_result = |{"success":"X","name":"{ lv_name }"}|.
+
+" CORRECT
+rv_result = |\{"success":"X","name":"{ lv_name }"\}|.
+```
+
+→ Full escaping rules and examples: `abapgit-agent ref --topic string-template`
+
+---
+
 ## See Also
 - **ABAP SQL** (sql.md) - for SQL syntax rules
 - **CDS Views** (cds.md) - for CDS selection patterns

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.3",
+  "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) {