abapgit-agent 1.14.4 → 1.15.0

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,13 +88,30 @@ 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.
+ *
+ * FUGR source includes follow L<group><suffix> naming (e.g. LSUSRU04, LSUSRTOP,
+ * LSUSRF10, L_ABAU01). They start with 'L' and are routed to programs/includes.
+ * Customer-namespace programs always start with Z/Y, so this branch is safe.
+ *
+ * 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`;
   }
+  // FUGR source includes: L<group>U<NN>, L<group>TOP, L<group>F<NN>, etc.
+  // All start with 'L'. Customer Z/Y programs never start with 'L'.
+  if (/^L/.test(upper)) {
+    return `/sap/bc/adt/programs/includes/${lower}`;
+  }
   return `/sap/bc/adt/programs/programs/${lower}`;
 }
 
@@ -247,11 +281,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 +345,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 +354,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/view.js

@@ -145,18 +145,38 @@ 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*[*"]/;
+  // Program-level header/declaration keywords that are not executable statements
+  const progDeclPattern = /^\s*(report|program|parameters|tables|selection-screen|select-options|class-pool|function-pool|interface-pool|type-pool|include)\b/i;
+  let inDeclBlock = false; // true while inside a multi-line DATA:/TYPES:/PARAMETERS: 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;
+    }
+    if (progDeclPattern.test(trimmed)) {
+      // Multi-line block (PARAMETERS: ...,\n  ...) stays open until period
+      if (!trimmed.endsWith('.')) inDeclBlock = true;
+      continue;
+    }
     return i;
   }
   return 0;
@@ -188,6 +208,15 @@ module.exports = {
     const jsonOutput = args.includes('--json');
     const fullMode = args.includes('--full');
     const linesMode = args.includes('--lines');
+    const fmArgIndex = args.indexOf('--fm');
+    const fmName = fmArgIndex !== -1 && fmArgIndex + 1 < args.length
+      ? args[fmArgIndex + 1].toUpperCase()
+      : null;
+
+    if (fmName && !fullMode) {
+      console.error('  Error: --fm requires --full');
+      process.exit(1);
+    }
 
     console.log(`\n  Viewing ${objects.length} object(s)`);
 
@@ -207,6 +236,10 @@ module.exports = {
       data.full = true;
     }
 
+    if (fmName) {
+      data.fm = fmName;
+    }
+
     const result = await http.post('/sap/bc/z_abapgit_agent/view', data, { csrfToken });
 
     // Handle uppercase keys from ABAP
@@ -277,11 +310,22 @@ module.exports = {
             const file = section.FILE || section.file || '';
             const lines = section.LINES || section.lines || [];
             const isCmSection = suffix.startsWith('CM') && methodName;
+            const isFugrFmSection = !isCmSection && !!methodName;
 
             if (linesMode) {
               // --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) {
@@ -292,13 +336,52 @@ module.exports = {
                   bpHint = `debug set --objects ${objName}:<global_line>`;
                 }
                 console.log(`  * ---- Method: ${methodName} (${suffix}) — breakpoint: ${bpHint} ----`);
+              } else if (isFugrFmSection) {
+                // Find first executable line: skip FUNCTION header, comments, blanks,
+                // and declaration blocks (DATA:, CONSTANTS:, TYPES:, etc.)
+                const declPat = /^\s*(data|final|types|constants|class-data)[\s:(]/i;
+                let firstExecLine = 1;
+                let inDecl = false;
+                for (let li = 0; li < lines.length; li++) {
+                  const t = lines[li].trim();
+                  if (inDecl) {
+                    if (t.endsWith('.')) inDecl = false;
+                    continue;
+                  }
+                  if (!t) continue;
+                  if (/^\*/.test(t)) continue;
+                  if (/^"/.test(t)) continue;
+                  if (/^function\s+/i.test(t)) continue;
+                  if (declPat.test(t)) {
+                    if (!t.endsWith('.')) inDecl = true;
+                    continue;
+                  }
+                  firstExecLine = li + 1;
+                  break;
+                }
+                const bpHint = `debug set --objects ${suffix}:${firstExecLine}`;
+                console.log(`  * ---- FM: ${methodName} (${suffix}) — breakpoint: ${bpHint} ----`);
               } else if (file) {
                 console.log(`  * ---- Section: ${section.DESCRIPTION || section.description} (from .clas.${file}.abap) ----`);
               } else if (suffix) {
-                console.log(`  * ---- Section: ${section.DESCRIPTION || section.description} (${suffix}) ----`);
+                // For program source sections, emit a breakpoint hint at the first executable line.
+                const isProgSection = suffix === 'PROG' || suffix === 'prog';
+                if (isProgSection) {
+                  const execOffset = findFirstExecutableLine(lines);
+                  const execLine = execOffset + 1; // 1-based
+                  const bpHint = `debug set --objects ${objName}:${execLine}`;
+                  console.log(`  * ---- Section: ${section.DESCRIPTION || section.description} (${suffix}) — breakpoint: ${bpHint} ----`);
+                } else {
+                  console.log(`  * ---- Section: ${section.DESCRIPTION || section.description} (${suffix}) ----`);
+                }
               }
 
               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;
@@ -306,8 +389,32 @@ module.exports = {
                   const gStr = globalLine ? String(globalLine).padStart(4) : '    ';
                   const iStr = String(includeRelLine).padStart(3);
                   console.log(`  ${gStr} [${iStr}]  ${codeLine}`);
+                } else if (isFugrFmSection) {
+                  // FM include: line numbers are include-relative = ADT line numbers
+                  const lStr = String(includeRelLine).padStart(4);
+                  console.log(`  ${lStr}  ${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}`);
                 }
               }
@@ -315,6 +422,8 @@ module.exports = {
               // --full (no --lines): clean source, no line numbers
               if (isCmSection) {
                 console.log(`  * ---- Method: ${methodName} (${suffix}) ----`);
+              } else if (isFugrFmSection) {
+                console.log(`  * ---- FM: ${methodName} (${suffix}) ----`);
               } else if (file) {
                 console.log(`  * ---- Section: ${section.DESCRIPTION || section.description} (from .clas.${file}.abap) ----`);
               } else if (suffix) {

package/src/utils/abap-reference.js

@@ -515,6 +515,8 @@ async function getTopic(topic) {
     // Map topic to local guideline file
     const guidelineMap = {
       'abapgit': 'abapgit.md',
+      'abapgit-xml-only': 'abapgit-xml-only.md',
+      'abapgit-fugr': 'abapgit-fugr.md',
       'xml': 'objects.md',
       'objects': 'objects.md',
       'naming': 'objects.md'