abapgit-agent 1.6.0 → 1.7.0

package/bin/abapgit-agent

@@ -538,12 +538,14 @@ async function processInspectResult(res) {
   const errorCount = res.ERROR_COUNT !== undefined ? res.ERROR_COUNT : (res.error_count || 0);
   const errors = res.ERRORS !== undefined ? res.ERRORS : (res.errors || []);
   const warnings = res.WARNINGS !== undefined ? res.WARNINGS : (res.warnings || []);
+  const infos = res.INFOS !== undefined ? res.INFOS : (res.infos || []);
 
-  if (errorCount > 0 || warnings.length > 0) {
+  if (errorCount > 0 || warnings.length > 0 || infos.length > 0) {
     if (errorCount > 0) {
       console.log(`❌ ${objectType} ${objectName} - Syntax check failed (${errorCount} error(s)):`);
     } else {
-      console.log(`⚠️  ${objectType} ${objectName} - Syntax check passed with warnings (${warnings.length}):`);
+      const total = warnings.length + infos.length;
+      console.log(`⚠️  ${objectType} ${objectName} - Syntax check passed with warnings (${total}):`);
     }
     console.log('\nErrors:');
     console.log('─'.repeat(60));
@@ -552,8 +554,16 @@ async function processInspectResult(res) {
       const line = err.LINE || err.line || '?';
       const column = err.COLUMN || err.column || '?';
       const text = err.TEXT || err.text || 'Unknown error';
+      const methodName = err.METHOD_NAME || err.method_name;
+      const sobjname = err.SOBJNAME || err.sobjname;
 
+      if (methodName) {
+        console.log(`  Method: ${methodName}`);
+      }
       console.log(`  Line ${line}, Column ${column}:`);
+      if (sobjname && sobjname.includes('====')) {
+        console.log(`    Include: ${sobjname}`);
+      }
       console.log(`    ${text}`);
       console.log('');
     }
@@ -565,7 +575,38 @@ async function processInspectResult(res) {
       for (const warn of warnings) {
         const line = warn.LINE || warn.line || '?';
         const text = warn.MESSAGE || warn.message || 'Unknown warning';
-        console.log(`  Line ${line}: ${text}`);
+        const methodName = warn.METHOD_NAME || warn.method_name;
+        const sobjname = warn.SOBJNAME || warn.sobjname;
+
+        if (methodName) {
+          console.log(`  Method: ${methodName}`);
+        }
+        console.log(`  Line ${line}:`);
+        if (sobjname && sobjname.includes('====')) {
+          console.log(`    Include: ${sobjname}`);
+        }
+        console.log(`    ${text}`);
+      }
+    }
+
+    // Show infos if any
+    if (infos.length > 0) {
+      console.log('Info:');
+      console.log('─'.repeat(60));
+      for (const info of infos) {
+        const line = info.LINE || info.line || '?';
+        const text = info.MESSAGE || info.message || 'Unknown info';
+        const methodName = info.METHOD_NAME || info.method_name;
+        const sobjname = info.SOBJNAME || info.sobjname;
+
+        if (methodName) {
+          console.log(`  Method: ${methodName}`);
+        }
+        console.log(`  Line ${line}:`);
+        if (sobjname && sobjname.includes('====')) {
+          console.log(`    Include: ${sobjname}`);
+        }
+        console.log(`    ${text}`);
       }
     }
   } else if (success === true || success === 'X') {
@@ -652,7 +693,7 @@ async function runUnitTests(options) {
 /**
  * Run unit test for a single file
  */
-async function runUnitTestForFile(sourceFile, csrfToken, config) {
+async function runUnitTestForFile(sourceFile, csrfToken, config, coverage = false) {
   console.log(`  Running unit test for: ${sourceFile}`);
 
   try {
@@ -687,7 +728,8 @@ async function runUnitTestForFile(sourceFile, csrfToken, config) {
 
     // Send files array to unit endpoint (ABAP expects string_table of file names)
     const data = {
-      files: [sourceFile]
+      files: [sourceFile],
+      coverage: coverage
     };
 
     const result = await request('POST', '/sap/bc/z_abapgit_agent/unit', data, { csrfToken });
@@ -700,6 +742,9 @@ async function runUnitTestForFile(sourceFile, csrfToken, config) {
     const message = result.MESSAGE || result.message || '';
     const errors = result.ERRORS || result.errors || [];
 
+    // Handle coverage data
+    const coverageStats = result.COVERAGE_STATS || result.coverage_stats;
+
     if (testCount === 0) {
       console.log(`  ➖ ${objName} - No unit tests`);
     } else if (success === 'X' || success === true) {
@@ -710,6 +755,17 @@ async function runUnitTestForFile(sourceFile, csrfToken, config) {
 
     console.log(`     Tests: ${testCount} | Passed: ${passedCount} | Failed: ${failedCount}`);
 
+    // Display coverage if available
+    if (coverage && coverageStats) {
+      const totalLines = coverageStats.TOTAL_LINES || coverageStats.total_lines || 0;
+      const coveredLines = coverageStats.COVERED_LINES || coverageStats.covered_lines || 0;
+      const coverageRate = coverageStats.COVERAGE_RATE || coverageStats.coverage_rate || 0;
+
+      console.log(`     📊 Coverage: ${coverageRate}%`);
+      console.log(`        Total Lines: ${totalLines}`);
+      console.log(`        Covered Lines: ${coveredLines}`);
+    }
+
     if (failedCount > 0 && errors.length > 0) {
       for (const err of errors) {
         const className = err.CLASS_NAME || err.class_name || '?';
@@ -1727,21 +1783,25 @@ Examples:
         const filesArgIndex = args.indexOf('--files');
         if (filesArgIndex === -1 || filesArgIndex + 1 >= args.length) {
           console.error('Error: --files parameter required');
-          console.error('Usage: abapgit-agent unit --files <file1>,<file2>,...');
+          console.error('Usage: abapgit-agent unit --files <file1>,<file2>,... [--coverage]');
           console.error('Example: abapgit-agent unit --files zcl_my_test.clas.abap');
+          console.error('Example: abapgit-agent unit --files zcl_my_test.clas.abap --coverage');
           process.exit(1);
         }
 
         const files = args[filesArgIndex + 1].split(',').map(f => f.trim());
 
-        console.log(`\n  Running unit tests for ${files.length} file(s)`);
+        // Check for coverage option
+        const coverage = args.includes('--coverage');
+
+        console.log(`\n  Running unit tests for ${files.length} file(s)${coverage ? ' (with coverage)' : ''}`);
         console.log('');
 
         const config = loadConfig();
         const csrfToken = await fetchCsrfToken(config);
 
         for (const sourceFile of files) {
-          await runUnitTestForFile(sourceFile, csrfToken, config);
+          await runUnitTestForFile(sourceFile, csrfToken, config, coverage);
         }
         break;
       }
@@ -2007,9 +2067,9 @@ Examples:
               console.log(`     ${description}`);
             }
 
-            // Display source code for classes, interfaces, and CDS views
+            // Display source code for classes, interfaces, CDS views, and programs/source includes
             const source = obj.SOURCE || obj.source || '';
-            if (source && (objType === 'INTF' || objType === 'Interface' || objType === 'CLAS' || objType === 'Class' || objType === 'DDLS' || objType === 'CDS View')) {
+            if (source && (objType === 'INTF' || objType === 'Interface' || objType === 'CLAS' || objType === 'Class' || objType === 'DDLS' || objType === 'CDS View' || objType === 'PROG' || objType === 'Program')) {
               console.log('');
               // Replace escaped newlines with actual newlines and display
               const displaySource = source.replace(/\\n/g, '\n');
@@ -2379,6 +2439,105 @@ Examples:
         break;
       }
 
+      case 'where': {
+        const objectsArgIndex = args.indexOf('--objects');
+        if (objectsArgIndex === -1 || objectsArgIndex + 1 >= args.length) {
+          console.error('Error: --objects parameter required');
+          console.error('Usage: abapgit-agent where --objects <obj1>,<obj2>,... [--type <type>] [--limit <n>] [--json]');
+          console.error('Example: abapgit-agent where --objects ZCL_MY_CLASS');
+          console.error('Example: abapgit-agent where --objects ZIF_MY_INTERFACE');
+          console.error('Example: abapgit-agent where --objects CL_SUT_AUNIT_RUNNER --limit 20');
+          process.exit(1);
+        }
+
+        const objects = args[objectsArgIndex + 1].split(',').map(o => o.trim().toUpperCase());
+        const typeArg = args.indexOf('--type');
+        const type = typeArg !== -1 ? args[typeArg + 1].toUpperCase() : null;
+        const limitArg = args.indexOf('--limit');
+        const limit = limitArg !== -1 ? parseInt(args[limitArg + 1], 10) : 100;
+        const jsonOutput = args.includes('--json');
+
+        console.log(`\n  Where-used list for ${objects.length} object(s)`);
+
+        const config = loadConfig();
+        const csrfToken = await fetchCsrfToken(config);
+
+        const data = {
+          objects: objects,
+          limit: Math.min(Math.max(1, limit), 500)
+        };
+
+        if (type) {
+          data.type = type;
+        }
+
+        const result = await request('POST', '/sap/bc/z_abapgit_agent/where', data, { csrfToken });
+
+        // Handle uppercase keys from ABAP
+        const success = result.SUCCESS || result.success;
+        const whereObjects = result.OBJECTS || result.objects || [];
+        const message = result.MESSAGE || result.message || '';
+        const error = result.ERROR || result.error;
+
+        if (!success || error) {
+          console.error(`\n  Error: ${error || 'Failed to get where-used list'}`);
+          break;
+        }
+
+        if (jsonOutput) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(`\n  ${message}`);
+          console.log('');
+
+          for (let i = 0; i < whereObjects.length; i++) {
+            const obj = whereObjects[i];
+            const objName = obj.NAME || obj.name || `Object ${i + 1}`;
+            const objType = obj.TYPE || obj.type || '';
+            const error = obj.ERROR || obj.error || '';
+            const references = obj.REFERENCES || obj.references || [];
+            const count = obj.COUNT || obj.count || 0;
+
+            // Handle object not found error
+            if (error) {
+              console.log(`  ❌ ${objName} (${objType})`);
+              console.log(`     ${error}`);
+              console.log('');
+              continue;
+            }
+
+            if (count === 0) {
+              console.log(`  ❌ ${objName} (${objType})`);
+              console.log(`     No references found`);
+              console.log('');
+              continue;
+            }
+
+            console.log(`  🔍 ${objName} (${objType})`);
+            console.log(`     Found ${count} reference(s):`);
+            console.log('');
+
+            // Display references - one line format: include → method (type) or include (type)
+            for (let j = 0; j < references.length; j++) {
+              const ref = references[j];
+              const includeName = ref.INCLUDE_NAME || ref.include_name || '';
+              const includeType = ref.INCLUDE_TYPE || ref.include_type || '';
+              const methodName = ref.METHOD_NAME || ref.method_name || '';
+
+              let line;
+              if (methodName) {
+                line = `  ${j + 1}. ${includeName} → ${methodName} (${includeType})`;
+              } else {
+                line = `  ${j + 1}. ${includeName} (${includeType})`;
+              }
+              console.log(line);
+            }
+            console.log('');
+          }
+        }
+        break;
+      }
+
       case 'ref': {
         const refSearch = require('../src/ref-search');
         const topicIndex = args.indexOf('--topic');
@@ -2452,32 +2611,10 @@ Examples:
         const pattern = args[patternIndex];
         const result = await refSearch.searchPattern(pattern);
 
-        // Also search guidelines if available
-        const guidelinesResult = await refSearch.searchGuidelines(pattern);
-        if (guidelinesResult && guidelinesResult.guidelinesFound && guidelinesResult.matches.length > 0) {
-          result.guidelines = guidelinesResult;
-        }
-
         if (jsonOutput) {
           console.log(JSON.stringify(result, null, 2));
         } else {
           refSearch.displaySearchResults(result);
-          // Display guidelines results if found
-          if (guidelinesResult && guidelinesResult.guidelinesFound && guidelinesResult.matches.length > 0) {
-            console.log('\n  📋 Custom Guidelines:');
-            for (const match of guidelinesResult.matches.slice(0, 5)) {
-              console.log(`    📄 ${match.file} (line ${match.line}):`);
-              const lines = match.context.split('\n');
-              lines.forEach((line, idx) => {
-                const prefix = idx === 1 ? '  → ' : '    ';
-                const trimmed = line.slice(0, 80);
-                console.log(`${prefix}${trimmed}`);
-              });
-            }
-            if (guidelinesResult.matches.length > 5) {
-              console.log(`    ... and ${guidelinesResult.matches.length - 5} more matches`);
-            }
-          }
         }
         break;
       }
@@ -2526,6 +2663,9 @@ Commands:
   view --objects <obj1>,<obj2>,... [--type <type>] [--json]
     View ABAP object definitions from the ABAP system
 
+  where --objects <obj1>,<obj2>,... [--type <type>] [--limit <n>] [--json]
+    Find where-used list for ABAP objects (classes, interfaces, programs)
+
   ref <pattern> [--json]
     Search ABAP reference repositories for patterns. Requires referenceFolder in .abapGitAgent.
 
@@ -2572,6 +2712,10 @@ Examples:
   abapgit-agent view --objects ZIF_MY_INTERFACE --type INTF       # View interface
   abapgit-agent view --objects ZMY_TABLE --type TABL               # View table structure
   abapgit-agent view --objects ZCL_CLASS1,ZCL_CLASS2 --json        # Multiple objects
+  abapgit-agent where --objects ZCL_SUT_AUNIT_RUNNER               # Find where class is used
+  abapgit-agent where --objects ZIF_MY_INTERFACE                   # Find interface implementations
+  abapgit-agent where --objects CL_SUT_AUNIT_RUNNER --limit 20    # Limit results
+  abapgit-agent where --objects ZIF_MY_INTERFACE --json            # JSON output
   abapgit-agent ref "CORRESPONDING"                         # Search all reference repos
   abapgit-agent ref "CX_SY_"                                 # Search exceptions
   abapgit-agent ref --topic exceptions                       # View exception topic

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abapgit-agent",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "ABAP Git Agent - Pull and activate ABAP code via abapGit from any git repository",
   "main": "src/index.js",
   "files": [
@@ -16,6 +16,10 @@
     "start": "node src/server.js",
     "dev": "nodemon src/server.js",
     "test": "jest",
+    "test:all": "node scripts/test-all.js",
+    "test:jest": "jest",
+    "test:aunit": "node scripts/test-all.js --jest --cmd",
+    "test:cmd": "node scripts/test-all.js --jest --aunit",
     "pull": "node bin/abapgit-agent",
     "release": "node scripts/release.js",
     "unrelease": "node scripts/unrelease.js"

package/src/abap-client.js

@@ -459,6 +459,52 @@ class ABAPClient {
 
     return await this.request('POST', '/list', data, { csrfToken: this.csrfToken });
   }
+
+  /**
+   * View ABAP object definitions
+   * @param {Array} objects - Array of object names to view
+   * @param {string} type - Object type (optional, e.g., 'CLAS', 'TABL')
+   * @returns {object} View result with object definitions
+   */
+  async view(objects, type = null) {
+    await this.fetchCsrfToken();
+
+    const data = {
+      objects: objects
+    };
+
+    if (type) {
+      data.type = type;
+    }
+
+    logger.info('Viewing objects', { objects, type, service: 'abapgit-agent' });
+
+    return await this.request('POST', '/view', data, { csrfToken: this.csrfToken });
+  }
+
+  /**
+   * Find where-used list for ABAP objects
+   * @param {Array} objects - Array of object names to search
+   * @param {string} type - Object type (optional)
+   * @param {number} limit - Maximum results (default: 100, max: 500)
+   * @returns {object} Where-used result with found objects
+   */
+  async where(objects, type = null, limit = 100) {
+    await this.fetchCsrfToken();
+
+    const data = {
+      objects: objects,
+      limit: Math.min(Math.max(1, limit), 500)
+    };
+
+    if (type) {
+      data.type = type;
+    }
+
+    logger.info('Finding where-used', { objects, type, limit: data.limit, service: 'abapgit-agent' });
+
+    return await this.request('POST', '/where', data, { csrfToken: this.csrfToken });
+  }
 }
 
 // Singleton instance

package/src/agent.js

@@ -264,6 +264,54 @@ class ABAPGitAgent {
       throw new Error(`List command failed: ${error.message}`);
     }
   }
+
+  /**
+   * View ABAP object definitions
+   * @param {Array} objects - Array of object names to view
+   * @param {string} type - Object type (optional, e.g., 'CLAS', 'TABL')
+   * @returns {object} View result with object definitions
+   */
+  async view(objects, type = null) {
+    logger.info('Viewing objects', { objects, type });
+
+    try {
+      const result = await this.abap.view(objects, type);
+      return {
+        success: result.SUCCESS === 'X' || result.success === 'X' || result.success === true,
+        command: result.COMMAND || result.command || 'VIEW',
+        objects: result.OBJECTS || result.objects || [],
+        error: result.ERROR || result.error || null
+      };
+    } catch (error) {
+      logger.error('View command failed', { error: error.message });
+      throw new Error(`View command failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Find where-used list for ABAP objects
+   * @param {Array} objects - Array of object names to search
+   * @param {string} type - Object type (optional)
+   * @param {number} limit - Maximum results (default: 100, max: 500)
+   * @returns {object} Where-used result with found objects
+   */
+  async where(objects, type = null, limit = 100) {
+    logger.info('Finding where-used', { objects, type, limit });
+
+    try {
+      const result = await this.abap.where(objects, type, limit);
+      return {
+        success: result.SUCCESS === 'X' || result.success === 'X' || result.success === true,
+        command: result.COMMAND || result.command || 'WHERE',
+        objects: result.OBJECTS || result.objects || [],
+        message: result.MESSAGE || result.message || '',
+        error: result.ERROR || result.error || null
+      };
+    } catch (error) {
+      logger.error('Where command failed', { error: error.message });
+      throw new Error(`Where command failed: ${error.message}`);
+    }
+  }
 }
 
 module.exports = {

package/src/config.js

@@ -24,7 +24,7 @@ function loadConfig() {
   if (fs.existsSync(configPath)) {
     config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
   } else {
-    // Load from environment variables
+    // Load from environment variables only when no config file exists
     config = {
       host: process.env.ABAP_HOST,
       sapport: parseInt(process.env.ABAP_PORT, 10) || 443,

package/src/ref-search.js

@@ -257,79 +257,117 @@ async function getSearchableFiles(repoPath, repoName, extensions = ['.md', '.aba
 }
 
 /**
- * Search for a pattern across all reference repositories
+ * Search for a pattern across all reference repositories and local guidelines
  * @param {string} pattern - Pattern to search for
  * @returns {Promise<Object>} Search results
  */
 async function searchPattern(pattern) {
   const refFolder = detectReferenceFolder();
   const repos = await getReferenceRepositories();
+  const guidelinesFolder = detectGuidelinesFolder();
 
-  if (!refFolder) {
+  // If neither reference folder nor guidelines exist, return error
+  if (!refFolder && !guidelinesFolder) {
     return {
       error: 'Reference folder not found',
-      hint: 'Configure referenceFolder in .abapGitAgent or clone to ~/abap-reference'
-    };
-  }
-
-  if (repos.length === 0) {
-    return {
-      error: 'No ABAP repositories found in reference folder',
-      hint: 'Clone ABAP repositories to the reference folder to enable searching'
+      hint: 'Configure referenceFolder in .abapGitAgent, clone to ~/abap-reference, or create abap/guidelines/ folder'
     };
   }
 
   const results = {
     pattern,
     referenceFolder: refFolder,
+    guidelinesFolder: guidelinesFolder,
     repositories: repos.map(r => r.name),
     files: [],
     matches: []
   };
 
   try {
-    // Search across all repositories
-    for (const repo of repos) {
-      const searchableFiles = await getSearchableFiles(repo.path, repo.name);
+    // Search reference repositories if available
+    if (repos.length > 0) {
+      for (const repo of repos) {
+        const searchableFiles = await getSearchableFiles(repo.path, repo.name);
+
+        for (const fileInfo of searchableFiles) {
+          try {
+            const content = await readFile(fileInfo.path, 'utf8');
+
+            if (content.toLowerCase().includes(pattern.toLowerCase())) {
+              results.files.push({
+                repo: repo.name,
+                file: fileInfo.relativePath
+              });
+
+              // Find matching lines with context
+              const lines = content.split('\n');
+              let matchCount = 0;
+
+              for (let i = 0; i < lines.length; i++) {
+                if (lines[i].toLowerCase().includes(pattern.toLowerCase())) {
+                  const start = Math.max(0, i - 1);
+                  const end = Math.min(lines.length, i + 2);
+                  const context = lines.slice(start, end).join('\n');
+
+                  results.matches.push({
+                    repo: repo.name,
+                    file: fileInfo.relativePath,
+                    line: i + 1,
+                    context
+                  });
+
+                  matchCount++;
+
+                  // Limit matches per file to avoid overwhelming output
+                  if (matchCount >= 3) {
+                    break;
+                  }
+                }
+              }
+            }
+          } catch (error) {
+            // Skip files we can't read
+          }
+        }
+      }
+    }
 
-      for (const fileInfo of searchableFiles) {
-        try {
-          const content = await readFile(fileInfo.path, 'utf8');
+    // Search local guidelines folder if available
+    if (guidelinesFolder) {
+      const guidelineFiles = await getGuidelineFiles();
 
-          if (content.toLowerCase().includes(pattern.toLowerCase())) {
-            results.files.push({
-              repo: repo.name,
-              file: fileInfo.relativePath
-            });
+      for (const file of guidelineFiles) {
+        if (file.content.toLowerCase().includes(pattern.toLowerCase())) {
+          results.files.push({
+            repo: 'guidelines',
+            file: file.relativePath
+          });
 
-            // Find matching lines with context
-            const lines = content.split('\n');
-            let matchCount = 0;
+          // Find matching lines with context
+          const lines = file.content.split('\n');
+          let matchCount = 0;
 
-            for (let i = 0; i < lines.length; i++) {
-              if (lines[i].toLowerCase().includes(pattern.toLowerCase())) {
-                const start = Math.max(0, i - 1);
-                const end = Math.min(lines.length, i + 2);
-                const context = lines.slice(start, end).join('\n');
+          for (let i = 0; i < lines.length; i++) {
+            if (lines[i].toLowerCase().includes(pattern.toLowerCase())) {
+              const start = Math.max(0, i - 1);
+              const end = Math.min(lines.length, i + 2);
+              const context = lines.slice(start, end).join('\n');
 
-                results.matches.push({
-                  repo: repo.name,
-                  file: fileInfo.relativePath,
-                  line: i + 1,
-                  context
-                });
+              results.matches.push({
+                repo: 'guidelines',
+                file: file.relativePath,
+                line: i + 1,
+                context
+              });
 
-                matchCount++;
+              matchCount++;
 
-                // Limit matches per file to avoid overwhelming output
-                if (matchCount >= 3) {
-                  break;
-                }
+              // Limit matches per file to avoid overwhelming output
+              if (matchCount >= 3) {
+                break;
               }
             }
           }
-        } catch (error) {
-          // Skip files we can't read
         }
       }
     }
@@ -469,7 +507,16 @@ function displaySearchResults(results) {
   }
 
   console.log(`\n  🔍 Searching for: '${results.pattern}'`);
-  console.log(`  📁 Reference folder: ${results.referenceFolder}`);
+
+  // Show which sources were searched
+  const sources = [];
+  if (results.referenceFolder) {
+    sources.push('reference repositories');
+  }
+  if (results.guidelinesFolder) {
+    sources.push('local guidelines');
+  }
+  console.log(`  📁 Sources searched: ${sources.join(', ') || 'none'}`);
 
   if (results.repositories && results.repositories.length > 0) {
     console.log(`  📚 Repositories (${results.repositories.length}): ${results.repositories.join(', ')}`);
@@ -491,7 +538,8 @@ function displaySearchResults(results) {
 
   console.log(`  ✅ Found in ${results.files.length} file(s):`);
   for (const [repo, files] of Object.entries(filesByRepo)) {
-    console.log(`\n     📦 ${repo}/`);
+    const icon = repo === 'guidelines' ? '📋' : '📦';
+    console.log(`\n     ${icon} ${repo}/`);
     files.forEach(file => {
       console.log(`        • ${file}`);
     });