abapgit-agent 1.11.1 → 1.11.2

package/src/commands/view.js

@@ -2,6 +2,166 @@
  * View command - View ABAP object definitions
  */
 
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Find the local .clas.abap file for an object by scanning the configured
+ * source folder (from the nearest .abapGitAgent config file).
+ * Returns the file path if found, null otherwise.
+ */
+function findLocalClassFile(objName) {
+  try {
+    // Try to read .abapGitAgent to get configured folder
+    let folder = null;
+    let dir = process.cwd();
+    for (let i = 0; i < 5; i++) {
+      const cfgPath = path.join(dir, '.abapGitAgent');
+      if (fs.existsSync(cfgPath)) {
+        try {
+          const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+          folder = cfg.folder;
+        } catch (e) { /* ignore */ }
+        break;
+      }
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+
+    // Normalise folder to a relative path segment (strip leading/trailing slashes)
+    const folderSeg = folder ? folder.replace(/^\/|\/$/g, '') : null;
+    const lowerName = objName.toLowerCase();
+    const fileName = `${lowerName}.clas.abap`;
+
+    const candidates = [];
+    if (folderSeg) {
+      candidates.push(path.join(process.cwd(), folderSeg, fileName));
+    }
+    candidates.push(path.join(process.cwd(), 'src', fileName));
+    candidates.push(path.join(process.cwd(), 'abap', fileName));
+    candidates.push(path.join(process.cwd(), fileName));
+
+    for (const candidate of candidates) {
+      if (fs.existsSync(candidate)) return candidate;
+    }
+  } catch (e) { /* ignore */ }
+  return null;
+}
+
+/**
+ * Given a fully assembled class source (array of lines, 1-indexed positions),
+ * return a map of { METHODNAME_UPPER: globalLineNumber } where globalLineNumber
+ * is the line on which `METHOD <name>.` appears.
+ *
+ * Matches lines where the first non-blank token is exactly "METHOD" (case-insensitive)
+ * to avoid false matches on comments or string literals.
+ */
+function buildMethodLineMap(sourceLines) {
+  const map = {};
+  for (let i = 0; i < sourceLines.length; i++) {
+    const condensed = sourceLines[i].trimStart();
+    if (/^method\s+/i.test(condensed)) {
+      // Extract method name: everything between "METHOD " and the next space/period/paren
+      const m = condensed.match(/^method\s+([\w~]+)/i);
+      if (m) {
+        map[m[1].toUpperCase()] = i + 1; // 1-based line number
+      }
+    }
+  }
+  return map;
+}
+
+/**
+ * Fetch the assembled class source from ADT.
+ * Returns an array of source lines, or null on failure.
+ */
+async function fetchAdtSource(objName, config) {
+  try {
+    const { AdtHttp } = require('../utils/adt-http');
+    const adt = new AdtHttp(config);
+    await adt.fetchCsrfToken();
+    const lower = objName.toLowerCase();
+    const resp = await adt.get(
+      `/sap/bc/adt/oo/classes/${lower}/source/main`,
+      { accept: 'text/plain' }
+    );
+    if (resp && resp.body) {
+      return resp.body.split('\n');
+    }
+  } catch (e) { /* ignore — fall through */ }
+  return null;
+}
+
+/**
+ * Compute global_start for each CM section in a sections array.
+ * Mutates sections in-place, adding a globalStart property.
+ *
+ * Strategy:
+ *  1. Try local .clas.abap file → build method line map
+ *  2. Fall back to ADT source fetch → build method line map
+ *  3. If neither works, leave globalStart = 0 (unknown)
+ *
+ * For non-CM sections (CU, CO, CP, CCDEF, CCIMP, CCAU) globalStart is also
+ * set from the source map for sections that have a unique recognisable first line,
+ * but for simplicity we set it to 0 for non-CM sections (they use section-local
+ * line numbers already).
+ */
+async function computeGlobalStarts(objName, sections, config) {
+  // Only CM sections need global_start for breakpoints
+  const cmSections = sections.filter(s => {
+    const suffix = s.SUFFIX || s.suffix || '';
+    const methodName = s.METHOD_NAME || s.method_name || '';
+    return suffix.startsWith('CM') && methodName;
+  });
+  if (cmSections.length === 0) return;
+
+  let sourceLines = null;
+
+  // Try local file first
+  const localFile = findLocalClassFile(objName);
+  if (localFile) {
+    try {
+      sourceLines = fs.readFileSync(localFile, 'utf8').split('\n');
+    } catch (e) { /* ignore */ }
+  }
+
+  // Fall back to ADT source fetch
+  if (!sourceLines) {
+    sourceLines = await fetchAdtSource(objName, config);
+  }
+
+  if (!sourceLines) return;
+
+  const methodLineMap = buildMethodLineMap(sourceLines);
+
+  for (const section of cmSections) {
+    const methodName = (section.METHOD_NAME || section.method_name || '').toUpperCase();
+    if (methodLineMap[methodName] !== undefined) {
+      section.globalStart = methodLineMap[methodName];
+    }
+  }
+}
+
+/**
+ * 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).
+ * 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 methodPattern = /^\s*method\s+/i;
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (!trimmed) continue;             // blank line
+    if (methodPattern.test(trimmed)) continue; // METHOD statement itself
+    if (declPattern.test(trimmed)) continue;   // declaration
+    return i;
+  }
+  return 0;
+}
+
 module.exports = {
   name: 'view',
   description: 'View ABAP object definitions from ABAP system',
@@ -24,6 +184,8 @@ module.exports = {
     const typeArg = args.indexOf('--type');
     const type = typeArg !== -1 ? args[typeArg + 1].toUpperCase() : null;
     const jsonOutput = args.includes('--json');
+    const fullMode = args.includes('--full');
+    const linesMode = args.includes('--lines');
 
     console.log(`\n  Viewing ${objects.length} object(s)`);
 
@@ -39,6 +201,10 @@ module.exports = {
       data.type = type;
     }
 
+    if (fullMode) {
+      data.full = true;
+    }
+
     const result = await http.post('/sap/bc/z_abapgit_agent/view', data, { csrfToken });
 
     // Handle uppercase keys from ABAP
@@ -52,6 +218,17 @@ module.exports = {
       return;
     }
 
+    // In full+lines mode, compute global line numbers client-side before rendering
+    if (fullMode && linesMode) {
+      for (const obj of viewObjects) {
+        const objName = obj.NAME || obj.name || '';
+        const sections = obj.SECTIONS || obj.sections || [];
+        if (sections.length > 0 && objName) {
+          await computeGlobalStarts(objName, sections, config);
+        }
+      }
+    }
+
     if (jsonOutput) {
       console.log(JSON.stringify(result, null, 2));
     } else {
@@ -86,7 +263,67 @@ module.exports = {
 
         // Display source code for classes, interfaces, CDS views, programs/source includes, and STOB
         const source = obj.SOURCE || obj.source || '';
-        if (source && (objType === 'INTF' || objType === 'Interface' || objType === 'CLAS' || objType === 'Class' || objType === 'DDLS' || objType === 'CDS View' || objType === 'PROG' || objType === 'Program' || objType === 'STOB' || objType === 'Structured Object')) {
+        const sections = obj.SECTIONS || obj.sections || [];
+
+        if (sections.length > 0) {
+          // --full mode: render all sections.
+          // --full --lines adds dual line numbers per line for debugging.
+          console.log('');
+          for (const section of sections) {
+            const suffix = section.SUFFIX || section.suffix || '';
+            const methodName = section.METHOD_NAME || section.method_name || '';
+            const file = section.FILE || section.file || '';
+            const lines = section.LINES || section.lines || [];
+            const isCmSection = suffix.startsWith('CM') && methodName;
+
+            if (linesMode) {
+              // --full --lines: dual line numbers (G [N]) for debugging
+              const globalStart = section.globalStart || 0;
+
+              if (isCmSection) {
+                let bpHint;
+                if (globalStart) {
+                  const execOffset = findFirstExecutableLine(lines);
+                  const execLine = globalStart + execOffset;
+                  bpHint = `debug set --objects ${objName}:${execLine}`;
+                } else {
+                  bpHint = `debug set --objects ${objName}:<global_line>`;
+                }
+                console.log(`  * ---- Method: ${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}) ----`);
+              }
+
+              let includeRelLine = 0;
+              for (const codeLine of lines) {
+                includeRelLine++;
+                const globalLine = globalStart ? globalStart + includeRelLine - 1 : 0;
+                if (isCmSection) {
+                  const gStr = globalLine ? String(globalLine).padStart(4) : '    ';
+                  const iStr = String(includeRelLine).padStart(3);
+                  console.log(`  ${gStr} [${iStr}]  ${codeLine}`);
+                } else {
+                  const lStr = globalLine ? String(globalLine).padStart(4) : String(includeRelLine).padStart(4);
+                  console.log(`  ${lStr}  ${codeLine}`);
+                }
+              }
+            } else {
+              // --full (no --lines): clean source, no line numbers
+              if (isCmSection) {
+                console.log(`  * ---- Method: ${methodName} (${suffix}) ----`);
+              } 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 (const codeLine of lines) {
+                console.log(`  ${codeLine}`);
+              }
+            }
+          }
+        } else if (source && (objType === 'INTF' || objType === 'Interface' || objType === 'CLAS' || objType === 'Class' || objType === 'DDLS' || objType === 'CDS View' || objType === 'PROG' || objType === 'Program' || objType === 'STOB' || objType === 'Structured Object')) {
           console.log('');
           // Replace escaped newlines with actual newlines and display
           const displaySource = source.replace(/\\n/g, '\n');

package/src/utils/abap-http.js

@@ -3,6 +3,7 @@
  */
 const https = require('https');
 const http = require('http');
+const { extractBodyDetail } = require('./format-error');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
@@ -269,9 +270,13 @@ class AbapHttp {
           let body = '';
           res.on('data', chunk => body += chunk);
           res.on('end', () => {
+            const detail = extractBodyDetail(body);
+            const message = detail
+              ? `(HTTP ${res.statusCode}) ${detail}`
+              : `(HTTP ${res.statusCode}) ${res.statusMessage || 'Internal Server Error'}`;
             reject({
               statusCode: res.statusCode,
-              message: `HTTP ${res.statusCode} error`,
+              message,
               body: body
             });
           });

package/src/utils/abap-reference.js

@@ -508,10 +508,10 @@ async function getTopic(topic) {
   if (guidelinesDir) {
     // Map topic to local guideline file
     const guidelineMap = {
-      'abapgit': '08_abapgit.md',
-      'xml': '06_objects.md',
-      'objects': '06_objects.md',
-      'naming': '06_objects.md'
+      'abapgit': 'abapgit.md',
+      'xml': 'objects.md',
+      'objects': 'objects.md',
+      'naming': 'objects.md'
     };
 
     const guidelineFile = guidelineMap[topicLower];

package/src/utils/adt-http.js

@@ -8,6 +8,7 @@ const https = require('https');
 const http = require('http');
 const fs = require('fs');
 const path = require('path');
+const { extractBodyDetail } = require('./format-error');
 const os = require('os');
 const crypto = require('crypto');
 
@@ -194,7 +195,11 @@ class AdtHttp {
           let respBody = '';
           res.on('data', chunk => respBody += chunk);
           res.on('end', () => {
-            reject({ statusCode: res.statusCode, message: `HTTP ${res.statusCode} error`, body: respBody });
+            const detail = extractBodyDetail(respBody);
+            const message = detail
+              ? `(HTTP ${res.statusCode}) ${detail}`
+              : `(HTTP ${res.statusCode}) ${res.statusMessage || 'Internal Server Error'}`;
+            reject({ statusCode: res.statusCode, message, body: respBody });
           });
           return;
         }

package/src/utils/format-error.js

@@ -0,0 +1,89 @@
+/**
+ * Shared HTTP error formatting utilities.
+ *
+ * When ABAP returns HTTP 4xx/5xx the abap-http.js layer captures the raw
+ * response body in `error.body`.  This module extracts a human-readable
+ * detail line from that body and provides a consistent display helper used
+ * by all command modules.
+ */
+
+/**
+ * Extract a short, human-readable detail string from an HTTP error's response
+ * body.  Handles the three common SAP response shapes:
+ *  - JSON with a `message` or `error` field  (our own ABAP handlers)
+ *  - SAP ICF XML/HTML error pages            (raw ICM 500 page)
+ *  - Plain text
+ *
+ * @param {string|object} body  - raw response body (string or already-parsed object)
+ * @returns {string|null}       - detail text, or null if nothing useful found
+ */
+function extractBodyDetail(body) {
+  if (!body) return null;
+
+  // Already a parsed object (e.g. CSRF error shape)
+  if (typeof body === 'object') {
+    return body.message || body.error || body.MESSAGE || body.ERROR || null;
+  }
+
+  // Try to parse as JSON first
+  try {
+    const parsed = JSON.parse(body);
+    return parsed.message || parsed.error || parsed.MESSAGE || parsed.ERROR || null;
+  } catch (_) {
+    // Not JSON — fall through
+  }
+
+  // SAP ICF HTML/XML error page: grab the first <p> or <title> content
+  const titleMatch = body.match(/<title[^>]*>([^<]+)<\/title>/i);
+  if (titleMatch) return titleMatch[1].trim();
+
+  const pMatch = body.match(/<p[^>]*>([^<]{10,})<\/p>/i);
+  if (pMatch) return pMatch[1].trim();
+
+  // Plain text — return first non-empty line (up to 200 chars)
+  const firstLine = body.split('\n').map(l => l.trim()).find(l => l.length > 0);
+  if (firstLine) return firstLine.substring(0, 200);
+
+  return null;
+}
+
+/**
+ * Build a display message for an HTTP error, including body detail when
+ * available.
+ *
+ * @param {Error|object} error  - error object from abap-http.js
+ * @returns {string}            - formatted message for console output
+ */
+function formatHttpError(error) {
+  const base = error.message || String(error);
+  const detail = extractBodyDetail(error.body);
+  if (detail && detail !== base) {
+    return `${base}\n     Detail: ${detail}`;
+  }
+  return base;
+}
+
+/**
+ * Print a formatted HTTP error to stderr.
+ * Optionally dump the full raw body when verbose mode is active.
+ *
+ * @param {Error|object} error    - error from abap-http.js
+ * @param {object}       [opts]   - options
+ * @param {boolean}      [opts.verbose=false]  - dump full raw body
+ * @param {string}       [opts.prefix='❌ Error']  - prefix for first line
+ */
+function printHttpError(error, { verbose = false, prefix = '❌ Error' } = {}) {
+  const msg = formatHttpError(error);
+  console.error(`\n${prefix}: ${msg}`);
+
+  if (verbose && error.body) {
+    console.error('\n--- Raw response body ---');
+    const raw = typeof error.body === 'object'
+      ? JSON.stringify(error.body, null, 2)
+      : String(error.body);
+    console.error(raw);
+    console.error('--- End of response body ---');
+  }
+}
+
+module.exports = { formatHttpError, printHttpError, extractBodyDetail };

package/abap/guidelines/00_index.md

@@ -1,44 +0,0 @@
----
-layout: default
-title: Overview
-nav_order: 1
-parent: ABAP Coding Guidelines
-grand_parent: ABAP Development
----
-
-# ABAP Coding Guidelines Index
-
-This folder contains detailed ABAP coding guidelines that can be searched using the `ref` command.
-
-## Guidelines Available
-
-| File | Topic |
-|------|-------|
-| `01_sql.md` | ABAP SQL Best Practices |
-| `02_exceptions.md` | Exception Handling |
-| `03_testing.md` | Unit Testing (including CDS) |
-| `04_cds.md` | CDS Views |
-| `05_classes.md` | ABAP Classes and Objects |
-| `06_objects.md` | Object Naming Conventions |
-| `07_json.md` | JSON Handling |
-| `08_abapgit.md` | abapGit XML Metadata Templates |
-| `09_unit_testable_code.md` | Unit Testable Code Guidelines (Dependency Injection) |
-
-## Usage
-
-These guidelines are automatically searched by the `ref` command:
-
-```bash
-# Search across all guidelines
-abapgit-agent ref "CORRESPONDING"
-
-# List all topics
-abapgit-agent ref --list-topics
-```
-
-## Adding Custom Guidelines
-
-To add your own guidelines:
-1. Create a new `.md` file in this folder
-2. Follow the naming convention: `XX_name.md`
-3. Export to reference folder: `abapgit-agent ref export`