abapgit-agent 1.14.3 → 1.14.5

package/abap/CLAUDE.md

@@ -426,17 +426,34 @@ Never assume — wait for the user's answer before proceeding.
 
 **Finding the right line number for a breakpoint:**
 
-Use `view --full --lines` to get assembled-source global line numbers (the `G` column) — these are the coordinates ADT accepts for breakpoints:
+Use `view --full --lines` to get ready-to-use `debug set` commands per method:
 
 ```bash
 abapgit-agent view --objects ZCL_FOO --full --lines
 ```
 
-Output format: `G [N]  code` where `G` = global line (use with `debug set`) and `[N]` = include-relative (for navigation only).
+**Regular methods (CM\*):** output shows `G [N]  code` — the method header has the exact hint:
+```
+  * ---- Method: DO_SOMETHING (CM002) — breakpoint: debug set --objects ZCL_FOO:90 ----
+   88 [  1]  METHOD do_something.
+   89 [  2]    DATA lv_x TYPE i.
+   90 [  3]    lv_x = 1.
+```
+`G` = global assembled-source line (for `debug set`), `[N]` = include-relative (navigation only).
+
+**Unit test methods (CCAU) and local class methods (CCIMP):** use `--include` flag with section-local line numbers:
+```
+  * ---- Method: SETUP — breakpoint: debug set --objects ZCL_FOO:12 --include testclasses ----
+  * ---- Method: ZIF_BAR~DO_IT — breakpoint: debug set --objects ZCL_FOO:5 --include locals_imp ----
+```
 
 ```bash
-# Example: METHOD do_something. starts at global line 87
-abapgit-agent debug set --objects ZCL_FOO:90   # set BP a few lines after METHOD statement
+# Regular method:
+abapgit-agent debug set --objects ZCL_FOO:90
+# Unit test method:
+abapgit-agent debug set --objects ZCL_FOO:12 --include testclasses
+# Local class method:
+abapgit-agent debug set --objects ZCL_FOO:5 --include locals_imp
 ```
 
 Minimal correct sequence:

package/abap/guidelines/abapgit.md

@@ -284,6 +284,156 @@ abapGit's serializer **omits fields that have their default value**. Writing ext
 
 **Why this matters**: Missing `SHLPORIGIN` or wrong `MASK`/`DDTEXT` order causes a permanent diff between git and the system-serialized XML.
 
+#### Text Tables and Foreign Keys
+
+A **text table** stores translatable texts for another table (the "main table"). It shares the same key fields as the main table plus a language field (`SPRAS` with data element `SPRAS`, or `LANGU` with data element `LANGU`).
+
+**How to recognise a text table relationship in the XML:**
+- `<DD09L>` has `<UEBERSETZ>X</UEBERSETZ>` — marks this table as a text table
+- `<DD08V>` has `<FRKART>TEXT</FRKART>` — marks the foreign key as a text-table relationship (ordinary foreign keys omit this field)
+
+**Three sections required in the text table XML:**
+
+| Section | Purpose |
+|---|---|
+| `DD03P_TABLE` | Field definitions — same key fields as main table + language field + text fields |
+| `DD05M_TABLE` | Foreign key field mappings — one entry per key field of the main table (excluding the language field) |
+| `DD08V_TABLE` | Foreign key relationship — one entry with `FRKART>TEXT` |
+
+**`DD03P` rules for the text table:**
+- First key field (`MANDT`) must have `<CHECKTABLE>` pointing to the main table and `<SHLPORIGIN>P</SHLPORIGIN>`
+- Language field (`SPRAS` or `LANGU`) gets `<SHLPORIGIN>D</SHLPORIGIN>` (added by serializer after activation — omit when writing manually)
+
+**`DD05M` rules:**
+- `FIELDNAME` = the anchor field in the text table (typically `MANDT` — the first key field)
+- `FORTABLE` = text table name
+- `FORKEY` = key field name in the main table
+- `CHECKFIELD` = same as `FORKEY`
+- `CHECKTABLE` = main table name
+- `PRIMPOS` = position sequence (0001, 0002, …)
+- `DOMNAME` / `DATATYPE` = domain and type of the check field (omit `DOMNAME` if unknown — serializer fills it in)
+
+**`DD08V` rules:**
+- `FIELDNAME` = same anchor field as used in `DD05M` (typically `MANDT`)
+- `CHECKTABLE` = main table name
+- `FRKART` = `TEXT` (text table) or omit (ordinary foreign key)
+- `CARD` = `CN` (n:1 cardinality)
+- `CARDLEFT` = `1`
+
+**Example — text table `ZMY_TABLE_T` for main table `ZMY_TABLE` (keys: MANDT, ID1, ID2):**
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<abapGit version="v1.0.0" serializer="LCL_OBJECT_TABL" serializer_version="v1.0.0">
+ <asx:abap xmlns:asx="http://www.sap.com/abapxml" version="1.0">
+  <asx:values>
+   <DD02V>
+    <TABNAME>ZMY_TABLE_T</TABNAME>
+    <DDLANGUAGE>E</DDLANGUAGE>
+    <TABCLASS>TRANSP</TABCLASS>
+    <CLIDEP>X</CLIDEP>
+    <DDTEXT>My Table: Texts</DDTEXT>
+    <CONTFLAG>C</CONTFLAG>
+   </DD02V>
+   <DD09L>
+    <TABNAME>ZMY_TABLE_T</TABNAME>
+    <AS4LOCAL>A</AS4LOCAL>
+    <TABKAT>0</TABKAT>
+    <TABART>APPL0</TABART>
+    <UEBERSETZ>X</UEBERSETZ>
+    <BUFALLOW>N</BUFALLOW>
+   </DD09L>
+   <DD03P_TABLE>
+    <DD03P>
+     <FIELDNAME>MANDT</FIELDNAME>
+     <KEYFLAG>X</KEYFLAG>
+     <ROLLNAME>MANDT</ROLLNAME>
+     <CHECKTABLE>ZMY_TABLE</CHECKTABLE>
+     <ADMINFIELD>0</ADMINFIELD>
+     <NOTNULL>X</NOTNULL>
+     <SHLPORIGIN>P</SHLPORIGIN>
+     <COMPTYPE>E</COMPTYPE>
+    </DD03P>
+    <DD03P>
+     <FIELDNAME>ID1</FIELDNAME>
+     <KEYFLAG>X</KEYFLAG>
+     <ROLLNAME>ZMY_ID1</ROLLNAME>
+     <ADMINFIELD>0</ADMINFIELD>
+     <NOTNULL>X</NOTNULL>
+     <COMPTYPE>E</COMPTYPE>
+    </DD03P>
+    <DD03P>
+     <FIELDNAME>ID2</FIELDNAME>
+     <KEYFLAG>X</KEYFLAG>
+     <ROLLNAME>ZMY_ID2</ROLLNAME>
+     <ADMINFIELD>0</ADMINFIELD>
+     <NOTNULL>X</NOTNULL>
+     <COMPTYPE>E</COMPTYPE>
+    </DD03P>
+    <DD03P>
+     <FIELDNAME>SPRAS</FIELDNAME>
+     <KEYFLAG>X</KEYFLAG>
+     <ROLLNAME>SPRAS</ROLLNAME>
+     <ADMINFIELD>0</ADMINFIELD>
+     <NOTNULL>X</NOTNULL>
+     <COMPTYPE>E</COMPTYPE>
+    </DD03P>
+    <DD03P>
+     <FIELDNAME>DESCRIPTION</FIELDNAME>
+     <ROLLNAME>ZMY_DESCRIPTION</ROLLNAME>
+     <ADMINFIELD>0</ADMINFIELD>
+     <COMPTYPE>E</COMPTYPE>
+    </DD03P>
+   </DD03P_TABLE>
+   <DD05M_TABLE>
+    <DD05M>
+     <FIELDNAME>MANDT</FIELDNAME>
+     <FORTABLE>ZMY_TABLE_T</FORTABLE>
+     <FORKEY>MANDT</FORKEY>
+     <CHECKTABLE>ZMY_TABLE</CHECKTABLE>
+     <CHECKFIELD>MANDT</CHECKFIELD>
+     <PRIMPOS>0001</PRIMPOS>
+     <DOMNAME>MANDT</DOMNAME>
+     <DATATYPE>CLNT</DATATYPE>
+    </DD05M>
+    <DD05M>
+     <FIELDNAME>MANDT</FIELDNAME>
+     <FORTABLE>ZMY_TABLE_T</FORTABLE>
+     <FORKEY>ID1</FORKEY>
+     <CHECKTABLE>ZMY_TABLE</CHECKTABLE>
+     <CHECKFIELD>ID1</CHECKFIELD>
+     <PRIMPOS>0002</PRIMPOS>
+     <DATATYPE>CHAR</DATATYPE>
+    </DD05M>
+    <DD05M>
+     <FIELDNAME>MANDT</FIELDNAME>
+     <FORTABLE>ZMY_TABLE_T</FORTABLE>
+     <FORKEY>ID2</FORKEY>
+     <CHECKTABLE>ZMY_TABLE</CHECKTABLE>
+     <CHECKFIELD>ID2</CHECKFIELD>
+     <PRIMPOS>0003</PRIMPOS>
+     <DATATYPE>CHAR</DATATYPE>
+    </DD05M>
+   </DD05M_TABLE>
+   <DD08V_TABLE>
+    <DD08V>
+     <FIELDNAME>MANDT</FIELDNAME>
+     <CHECKTABLE>ZMY_TABLE</CHECKTABLE>
+     <FRKART>TEXT</FRKART>
+     <CARD>CN</CARD>
+     <CARDLEFT>1</CARDLEFT>
+    </DD08V>
+   </DD08V_TABLE>
+  </asx:values>
+ </asx:abap>
+</abapGit>
+```
+
+**Key rules:**
+- Always activate the main table **before** the text table — the foreign key check requires the main table to exist
+- Language field can be `SPRAS` (data element `SPRAS`) or `LANGU` (data element `LANGU`) — both are recognised by the system
+- For an **ordinary foreign key** (not a text table): same `DD05M`/`DD08V` structure, but omit `<FRKART>TEXT</FRKART>` from `DD08V`
+
 ---
 
 ### CDS View / View Entity (DDLS)

package/abap/guidelines/debug-session.md

@@ -17,7 +17,7 @@ Use `debug` when:
 
 **Step 1 — set a breakpoint** on the first executable statement you want to inspect:
 
-Use `view --objects ZCL_MY_CLASS --full --lines` to see the full source with **both** global assembled-source line numbers and include-relative `[N]` numbers:
+Use `view --objects ZCL_MY_CLASS --full --lines` to see the full source with line numbers and ready-to-use `debug set` commands:
 
 ```bash
 abapgit-agent view --objects ZCL_MY_CLASS --full --lines
@@ -25,16 +25,11 @@ abapgit-agent view --objects ZCL_MY_CLASS --full --lines
 
 > **Tip**: `view --full` (without `--lines`) shows the same full source as clean readable code without line numbers — useful for understanding logic. Add `--lines` when you need line numbers for breakpoints.
 
-Each line is shown as `G [N]  code` where:
-- **G** = assembled-source global line → use with `debug set --objects CLASS:G` or `debug set --files src/cls.clas.abap:G`
-- **[N]** = include-relative (restarts at 1 per method) → for code navigation only, not for breakpoints
+The output varies by section type:
 
-The method header shows the ready-to-use `debug set` command pointing to the first executable line:
+**Regular methods (CM\* sections)** — dual line numbers `G [N]` per line, with a `debug set` hint at the method header:
 
 ```
-   1  CLASS zcl_my_class DEFINITION.
-   2    PUBLIC SECTION.
-   3  ENDCLASS.
   * ---- Method: EXECUTE (CM002) — breakpoint: debug set --objects ZCL_MY_CLASS:9 ----
    7 [  1]  METHOD execute.
    8 [  2]    DATA lv_x TYPE i.
@@ -42,44 +37,69 @@ The method header shows the ready-to-use `debug set` command pointing to the fir
   10 [  4]  ENDMETHOD.
 ```
 
-**Two scenarios:**
+- **G** = assembled-source global line → use with `debug set --objects CLASS:G` or `--files src/cls.clas.abap:G`
+- **[N]** = include-relative (restarts at 1 per method) → for code navigation only, not for breakpoints
+
+The hint already points to the first **executable** line, skipping `METHOD`, blank lines, comments, and all declaration forms (`DATA`, `DATA:`, `DATA(`).
+
+**Two scenarios for CM* methods:**
 
 | Scenario | Command |
 |---|---|
 | Source available locally (your own classes) | `debug set --files src/zcl_my_class.clas.abap:9` |
 | No local source (abapGit library, SAP standard) | `debug set --objects ZCL_MY_CLASS:9` |
 
-Both use the same assembled-source global line number **G** shown in the output. To set a breakpoint at `lv_x = 1.` (global line 9):
 ```bash
-# With local file:
-abapgit-agent debug set --files src/zcl_my_class.clas.abap:9
-# Without local file:
 abapgit-agent debug set --objects ZCL_MY_CLASS:9
 abapgit-agent debug list    # confirm it was registered
 ```
 
-> **Line number must point to an executable statement.** The method header hint already skips the `METHOD` line, blank lines, and `DATA`/`FINAL`/`TYPES`/`CONSTANTS` declarations automatically. Two cases still require manual attention when picking a line from the output:
->
-> 1. **Comment lines** — lines starting with `"` are never executable. ADT silently rejects the breakpoint.
->    Pick the next non-comment line instead.
->    ```
->     95 [ 70]    " --- Conflict detection ---   ← NOT valid (comment)
->     96 [ 71]    " Build remote file entries…   ← NOT valid (comment)
->     97 [ 73]    DATA(lt_file_entries) = …      ← valid ✅ (use global 97)
->    ```
->
-> 2. **First line of a multi-line inline `DATA(x) = call(`** — the ABAP debugger treats the
->    `DATA(x) =` line as a declaration, not an executable step. Set the breakpoint on the
->    **next standalone executable statement** after the closing `).` instead.
->    ```
->    100 [ 92]    DATA(ls_checks) = prepare_deserialize_checks(   ← NOT valid (inline decl)
->    101 [ 93]      it_files = it_files                           ← NOT valid (continuation)
->    104 [ 96]      io_repo_desc = lo_repo_desc1 ).               ← NOT valid (continuation)
->    106 [ 98]    mo_repo->create_new_log( ).                     ← valid ✅ (use global 106)
->    ```
+**Unit test methods (CCAU section)** and **local class methods (CCIMP section)** live in separate ADT includes — they cannot be addressed by the assembled-source global line. Their sections show section-local line numbers with a `--include` hint per method:
+
+```
+  * ---- Section: Unit Test (from .clas.testclasses.abap) ----
+  * ---- Method: SETUP — breakpoint: debug set --objects ZCL_MY_CLASS:12 --include testclasses ----
+    10    METHOD setup.
+    11      DATA lv_x TYPE i.
+    12      mo_cut = NEW #( ).
+    13    ENDMETHOD.
+  * ---- Method: TEST_PULL_SUCCESS — breakpoint: debug set --objects ZCL_MY_CLASS:18 --include testclasses ----
+    15    METHOD test_pull_success.
+    ...
+
+  * ---- Section: Local Implementations (from .clas.locals_imp.abap) ----
+  * ---- Method: ZIF_FOO~DO_SOMETHING — breakpoint: debug set --objects ZCL_MY_CLASS:5 --include locals_imp ----
+    3     METHOD zif_foo~do_something.
+    4       DATA lv_x TYPE i.
+    5       lv_x = iv_input.
+    6     ENDMETHOD.
+```
+
+The line numbers in these sections are **section-local** (same coordinate system as the `.clas.testclasses.abap` / `.clas.locals_imp.abap` file). Use the `--include` flag to target the correct ADT sub-include:
+
+| Section | `--include` value |
+|---|---|
+| Unit Test (`.clas.testclasses.abap`) | `testclasses` |
+| Local Implementations (`.clas.locals_imp.abap`) | `locals_imp` |
+| Local Definitions (`.clas.locals_def.abap`) | `locals_def` |
+
+```bash
+# Unit test method:
+abapgit-agent debug set --objects ZCL_MY_CLASS:12 --include testclasses
+# Local class method:
+abapgit-agent debug set --objects ZCL_MY_CLASS:5 --include locals_imp
+abapgit-agent debug list    # confirm both were registered
+```
+
+> **Line number must point to an executable statement.** The hints already skip `METHOD`, blank lines, comments (`"`, `*`), and all declaration forms (`DATA`, `DATA:`, `DATA(`). One case still requires manual attention:
 >
-> Other non-executable lines: blank lines, `METHOD`/`ENDMETHOD`, `DATA:` declarations,
-> `CLASS`/`ENDCLASS`. When in doubt, prefer a simple method call or assignment.
+> **Multi-line inline `DATA(x) = call(`** — the ABAP debugger treats the whole expression as a declaration. Set the breakpoint on the **next standalone statement** after the closing `).`:
+> ```
+>  100 [  1]    DATA(ls_checks) = prepare_deserialize_checks(   ← NOT valid (inline decl)
+>  101 [  2]      it_files = it_files                           ← NOT valid (continuation)
+>  104 [  5]      io_repo_desc = lo_repo_desc1 ).               ← NOT valid (continuation)
+>  106 [  7]    mo_repo->create_new_log( ).                     ← valid ✅ (use global 106)
+>  ```
 
 **Step 2 — attach and trigger**
 
@@ -259,22 +279,24 @@ HTTP Request
 
 ### Known Limitations and Planned Improvements
 
-The following issues were identified during a live debugging session (2026-03) and should be fixed to make future debugging easier:
+The following issues were identified during live debugging sessions and resolved:
 
 #### ~~1. `view --full` global line numbers don't match ADT line numbers~~ ✅ Fixed
 
-**Fixed**: `view --full --lines` now shows dual line numbers per line: `G [N]  code` where G is the assembled-source global line (usable directly with `--objects CLASS:G` or `--files src/cls.clas.abap:G`) and `[N]` is the include-relative counter for navigation. Method headers show the ready-to-use `debug set --objects CLASS:G` command pointing to the first executable statement. `view --full` (without `--lines`) shows the same full source as clean readable code without line numbers.
+**Fixed**: `view --full --lines` now shows dual line numbers per line: `G [N]  code` where G is the assembled-source global line and `[N]` is the include-relative counter. Method headers show the ready-to-use `debug set --objects CLASS:G` command pointing to the first executable statement (skipping `METHOD`, blank lines, comments, and all `DATA`/`DATA:`/`DATA(` declaration forms).
 
 Global line numbers are computed **client-side** in Node.js, not in ABAP:
 - **Own classes** (local `.clas.abap` file exists): reads the local file — guaranteed exact match with ADT
 - **Library classes** (no local file, e.g. abapGit): fetches assembled source from `/sap/bc/adt/oo/classes/<name>/source/main`
 
-Both strategies scan for `METHOD <name>.` as the first token on the line to find `global_start`. The method header hint automatically points to the **first executable statement** (skipping the `METHOD` line, blank lines, and `DATA`/`FINAL`/`TYPES`/`CONSTANTS` declarations) so it can be used directly without adjustment.
+#### ~~2. No breakpoint support for unit test and local class methods~~ ✅ Fixed
+
+**Fixed**: CCAU (unit test) and CCIMP (local class implementation) sections in `view --full --lines` now show per-method `debug set --objects CLASS:N --include <type>` hints. These use the `/includes/<type>` ADT sub-include URI which ADT accepts for CCAU/CCIMP includes. See Step 1 above for details.
 
-#### ~~2. Include-relative breakpoint form (`=====CMxxx:N`) not implemented in the CLI~~ ✅ Superseded
+#### ~~3. Include-relative breakpoint form (`=====CMxxx:N`) not implemented in the CLI~~ ✅ Superseded
 
 **Superseded**: The `/programs/includes/` ADT endpoint was found to not accept breakpoints for OO class method includes — ADT only accepts the `/oo/classes/.../source/main` URI with assembled-source line numbers. The `=====CMxxx:N` approach was dropped. Instead, `view --full --lines` now provides the correct assembled-source global line number G directly, and both `--objects CLASS:G` and `--files src/cls.clas.abap:G` work reliably.
 
-#### ~~3. `stepContinue` re-attach pattern missing from docs~~ ✅ Fixed
+#### ~~4. `stepContinue` re-attach pattern missing from docs~~ ✅ Fixed
 
 **Fixed**: Step 3 of the debug guide now documents the two possible return values of `step --type continue` and includes the re-attach pattern for when the program hits a second breakpoint instead of finishing.

package/package.json

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

package/src/commands/debug.js

@@ -60,6 +60,23 @@ function hasFlag(args, flag) {
   return args.includes(flag);
 }
 
+/**
+ * Valid class include types for --include flag.
+ * User-facing names mirror the abapGit file suffixes (.clas.<name>.abap).
+ * Maps user-facing name → ADT /includes/<type> path segment.
+ * Verified by live ADT testing: breakpoints accepted for all three.
+ *   testclasses → testclasses   → CCAU  (unit test class file)
+ *   locals_imp  → implementations → CCIMP (local class implementations)
+ *   locals_def  → definitions   → CCDEF (local class definitions)
+ */
+const CLASS_INCLUDE_TYPES = new Set(['testclasses', 'locals_imp', 'locals_def']);
+
+const INCLUDE_TYPE_TO_ADT = {
+  testclasses: 'testclasses',
+  locals_imp:  'implementations',
+  locals_def:  'definitions',
+};
+
 /**
  * Determine ADT object URI from object name (class/interface vs program vs include).
  * Must use /source/main suffix for classes — verified by live testing: ADT
@@ -71,11 +88,19 @@ function hasFlag(args, flag) {
  * Class method includes are named <ClassName padded to 30 chars with '='>CM<suffix>
  * e.g. ZCL_ABGAGT_AGENT=============CM00D
  * These must be routed to the programs/includes ADT endpoint.
+ *
+ * When includeType is supplied (testclasses|locals_imp|locals_def),
+ * the URI targets the sub-include of the class instead of /source/main.
+ * Line numbers are then section-local (from the .clas.<file>.abap file).
  */
-function objectUri(name) {
+function objectUri(name, includeType) {
   const upper = (name || '').toUpperCase();
   const lower = upper.toLowerCase();
   if (/^[ZY](CL|IF)_/.test(upper) || /^(ZCL|ZIF|YCL|YIF)/.test(upper)) {
+    if (includeType && CLASS_INCLUDE_TYPES.has(includeType)) {
+      const adtType = INCLUDE_TYPE_TO_ADT[includeType];
+      return `/sap/bc/adt/oo/classes/${lower}/includes/${adtType}`;
+    }
     return `/sap/bc/adt/oo/classes/${lower}/source/main`;
   }
   return `/sap/bc/adt/programs/programs/${lower}`;
@@ -247,11 +272,18 @@ function parseBreakpointToken(token) {
 }
 
 async function cmdSet(args, config, adt) {
-  const objectName = val(args, '--object');
-  const lineRaw    = val(args, '--line');
-  const filesArg   = val(args, '--files');
-  const objectsArg = val(args, '--objects');
-  const jsonOutput = hasFlag(args, '--json');
+  const objectName  = val(args, '--object');
+  const lineRaw     = val(args, '--line');
+  const filesArg    = val(args, '--files');
+  const objectsArg  = val(args, '--objects');
+  const includeType = val(args, '--include');
+  const jsonOutput  = hasFlag(args, '--json');
+
+  // Validate --include if supplied
+  if (includeType && !CLASS_INCLUDE_TYPES.has(includeType)) {
+    console.error(`  Error: --include must be one of: ${[...CLASS_INCLUDE_TYPES].join(', ')}`);
+    process.exit(1);
+  }
 
   // Collect all breakpoints to add from every accepted input form
   const toAdd = []; // [{ name, line }]
@@ -304,6 +336,7 @@ async function cmdSet(args, config, adt) {
     console.error('    debug set --files src/zcl_my_class.clas.abap:42');
     console.error('    debug set --objects ZCL_MY_CLASS:42');
     console.error('    debug set --object ZCL_MY_CLASS --line 42');
+    console.error('    debug set --objects ZCL_MY_CLASS:16 --include testclasses');
     process.exit(1);
   }
 
@@ -312,7 +345,7 @@ async function cmdSet(args, config, adt) {
   const added = [];
 
   for (const { name, line } of toAdd) {
-    const uri = objectUri(name);
+    const uri = objectUri(name, includeType);
     const objUpper = name.toUpperCase();
     // Skip if an identical breakpoint already exists
     if (existing.some(bp => bp.object === objUpper && bp.line === line)) {

package/src/commands/lint.js

@@ -66,29 +66,44 @@ module.exports = {
     const allFiles = [...new Set([...abapFiles, ...depFiles])];
     cfg.global.files = allFiles.map(f => `/${f}`);
 
-    // Exclude dependency files from reporting — they are included only for
-    // cross-reference resolution. Only the originally changed files are reported on.
-    const abapFilesSet = new Set(abapFiles);
-    const excludedDeps = depFiles
-      .filter(f => !abapFilesSet.has(f))
-      .map(f => `/${f}`);
-    if (excludedDeps.length > 0) {
-      cfg.global.exclude = [...new Set([...(cfg.global.exclude || []), ...excludedDeps])];
-    }
-
     const scopedConfig = '.abaplint-local.json';
     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);
@@ -178,7 +193,7 @@ function resolveDependencies(abapFiles, fileIndex) {
 
   // 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,
   ];
@@ -238,6 +253,30 @@ function resolveDependencies(abapFiles, fileIndex) {
   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).

package/src/commands/view.js

@@ -145,18 +145,31 @@ async function computeGlobalStarts(objName, sections, config) {
 
 /**
  * Given the lines of a CM method section, return the 0-based index of the
- * first "executable" line — i.e. skip METHOD, blank lines, and pure
- * declaration lines (DATA/FINAL/TYPES/CONSTANTS/CLASS-DATA).
+ * first "executable" line — i.e. skip METHOD, blank lines, comment lines,
+ * and declaration lines (DATA/FINAL/TYPES/CONSTANTS/CLASS-DATA), including
+ * multi-line DATA: blocks whose continuation lines end with a period.
  * Returns 0 if no better line is found (falls back to METHOD statement).
  */
 function findFirstExecutableLine(lines) {
-  const declPattern = /^\s*(data|final|types|constants|class-data)[\s:]/i;
+  const declPattern = /^\s*(data|final|types|constants|class-data)[\s:(]/i;
   const methodPattern = /^\s*method\s+/i;
+  const commentPattern = /^\s*[*"]/;
+  let inDeclBlock = false; // true while inside a multi-line DATA:/TYPES: block
   for (let i = 0; i < lines.length; i++) {
     const trimmed = lines[i].trim();
+    if (inDeclBlock) {
+      // continuation line — skip until the block closes with a period
+      if (trimmed.endsWith('.')) inDeclBlock = false;
+      continue;
+    }
     if (!trimmed) continue;             // blank line
     if (methodPattern.test(trimmed)) continue; // METHOD statement itself
-    if (declPattern.test(trimmed)) continue;   // declaration
+    if (commentPattern.test(trimmed)) continue; // comment line
+    if (declPattern.test(trimmed)) {
+      // Multi-line block (DATA: ...,\n  ...) stays open until period
+      if (!trimmed.endsWith('.')) inDeclBlock = true;
+      continue;
+    }
     return i;
   }
   return 0;
@@ -282,6 +295,16 @@ module.exports = {
               // --full --lines: dual line numbers (G [N]) for debugging
               const globalStart = section.globalStart || 0;
 
+              // Map abapGit file suffix to the --include flag value used in debug set hints.
+              // User-facing names mirror the abapGit file suffixes (.clas.<name>.abap).
+              // Verified by live ADT testing: /includes/<adtType> endpoint accepts BPs.
+              const INCLUDE_FLAG_VALUE = {
+                testclasses:  'testclasses',
+                locals_imp:   'locals_imp',
+                locals_def:   'locals_def',
+              };
+              const includeFlag = INCLUDE_FLAG_VALUE[file] || null;
+
               if (isCmSection) {
                 let bpHint;
                 if (globalStart) {
@@ -299,6 +322,11 @@ module.exports = {
               }
 
               let includeRelLine = 0;
+              // Track when we're inside a METHOD block in a sub-include section
+              // so we can emit a breakpoint hint at the first executable line.
+              let inSubMethod = false;
+              let subMethodName = '';
+              let subMethodStartLine = 0; // 1-based line of METHOD statement
               for (const codeLine of lines) {
                 includeRelLine++;
                 const globalLine = globalStart ? globalStart + includeRelLine - 1 : 0;
@@ -307,7 +335,27 @@ module.exports = {
                   const iStr = String(includeRelLine).padStart(3);
                   console.log(`  ${gStr} [${iStr}]  ${codeLine}`);
                 } else {
-                  const lStr = globalLine ? String(globalLine).padStart(4) : String(includeRelLine).padStart(4);
+                  // For sub-include sections with a known ADT include type,
+                  // detect METHOD..ENDMETHOD blocks and emit breakpoint hints.
+                  if (includeFlag) {
+                    const trimmed = codeLine.trim();
+                    if (!inSubMethod && /^method\s+/i.test(trimmed)) {
+                      // Entering a new method — find first executable line offset
+                      // by scanning ahead from this line
+                      const mName = (trimmed.match(/^method\s+([\w~]+)/i) || [])[1] || '';
+                      // Collect lines from this METHOD onwards to find exec offset
+                      const remainingLines = lines.slice(includeRelLine - 1); // 0-based from current
+                      const execOffset = findFirstExecutableLine(remainingLines);
+                      const execLine = includeRelLine + execOffset; // section-local line
+                      const bpHint = `debug set --objects ${objName}:${execLine} --include ${includeFlag}`;
+                      console.log(`  * ---- Method: ${mName.toUpperCase()} — breakpoint: ${bpHint} ----`);
+                      inSubMethod = true;
+                      subMethodName = mName;
+                    } else if (inSubMethod && /^endmethod\s*\./i.test(codeLine.trim())) {
+                      inSubMethod = false;
+                    }
+                  }
+                  const lStr = String(includeRelLine).padStart(4);
                   console.log(`  ${lStr}  ${codeLine}`);
                 }
               }