abapgit-agent 1.7.2 → 1.8.0

package/src/commands/unit.js

@@ -0,0 +1,133 @@
+/**
+ * Unit command - Run AUnit tests for ABAP test class files
+ */
+
+const pathModule = require('path');
+const fs = require('fs');
+
+/**
+ * Run unit test for a single file
+ */
+async function runUnitTestForFile(sourceFile, csrfToken, config, coverage, http) {
+  console.log(`  Running unit test for: ${sourceFile}`);
+
+  try {
+    // Read file content
+    const absolutePath = pathModule.isAbsolute(sourceFile)
+      ? sourceFile
+      : pathModule.join(process.cwd(), sourceFile);
+
+    if (!fs.existsSync(absolutePath)) {
+      console.error(`  ❌ File not found: ${absolutePath}`);
+      return;
+    }
+
+    // Extract object type and name from file path
+    // e.g., "zcl_my_test.clas.abap" -> CLAS, ZCL_MY_TEST
+    const fileName = pathModule.basename(sourceFile).toUpperCase();
+    const parts = fileName.split('.');
+    if (parts.length < 3) {
+      console.error(`  ❌ Invalid file format: ${sourceFile}`);
+      return;
+    }
+
+    // obj_name is first part (may contain path), obj_type is second part
+    const objType = parts[1] === 'CLASS' ? 'CLAS' : parts[1];
+    let objName = parts[0];
+
+    // Handle subdirectory paths
+    const lastSlash = objName.lastIndexOf('/');
+    if (lastSlash >= 0) {
+      objName = objName.substring(lastSlash + 1);
+    }
+
+    // Send files array to unit endpoint (ABAP expects string_table of file names)
+    const data = {
+      files: [sourceFile],
+      coverage: coverage
+    };
+
+    const result = await http.post('/sap/bc/z_abapgit_agent/unit', data, { csrfToken });
+
+    // Handle uppercase keys from ABAP
+    const success = result.SUCCESS || result.success;
+    const testCount = result.TEST_COUNT || result.test_count || 0;
+    const passedCount = result.PASSED_COUNT || result.passed_count || 0;
+    const failedCount = result.FAILED_COUNT || result.failed_count || 0;
+    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) {
+      console.log(`  ✅ ${objName} - All tests passed`);
+    } else {
+      console.log(`  ❌ ${objName} - Tests failed`);
+    }
+
+    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 || '?';
+        const methodName = err.METHOD_NAME || err.method_name || '?';
+        const errorText = err.ERROR_TEXT || err.error_text || 'Unknown error';
+        console.log(`     ✗ ${className}=>${methodName}: ${errorText}`);
+      }
+    }
+
+    return result;
+  } catch (error) {
+    console.error(`\n  Error: ${error.message}`);
+  }
+}
+
+module.exports = {
+  name: 'unit',
+  description: 'Run AUnit tests for ABAP test class files',
+  requiresAbapConfig: true,
+  requiresVersionCheck: true,
+
+  async execute(args, context) {
+    const { loadConfig, AbapHttp } = context;
+
+    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>,... [--coverage]');
+      console.error('Example: abapgit-agent unit --files src/zcl_my_test.clas.abap');
+      console.error('Example: abapgit-agent unit --files src/zcl_my_test.clas.abap --coverage');
+      process.exit(1);
+    }
+
+    const files = args[filesArgIndex + 1].split(',').map(f => f.trim());
+
+    // 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 http = new AbapHttp(config);
+    const csrfToken = await http.fetchCsrfToken();
+
+    for (const sourceFile of files) {
+      await runUnitTestForFile(sourceFile, csrfToken, config, coverage, http);
+    }
+  }
+};

package/src/commands/view.js

@@ -0,0 +1,215 @@
+/**
+ * View command - View ABAP object definitions
+ */
+
+module.exports = {
+  name: 'view',
+  description: 'View ABAP object definitions from ABAP system',
+  requiresAbapConfig: true,
+  requiresVersionCheck: true,
+
+  async execute(args, context) {
+    const { loadConfig, AbapHttp } = context;
+
+    const objectsArgIndex = args.indexOf('--objects');
+    if (objectsArgIndex === -1 || objectsArgIndex + 1 >= args.length) {
+      console.error('Error: --objects parameter required');
+      console.error('Usage: abapgit-agent view --objects <obj1>,<obj2>,... [--type <type>] [--json]');
+      console.error('Example: abapgit-agent view --objects ZCL_MY_CLASS');
+      console.error('Example: abapgit-agent view --objects ZCL_CLASS1,ZCL_CLASS2 --type CLAS');
+      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 jsonOutput = args.includes('--json');
+
+    console.log(`\n  Viewing ${objects.length} object(s)`);
+
+    const config = loadConfig();
+    const http = new AbapHttp(config);
+    const csrfToken = await http.fetchCsrfToken();
+
+    const data = {
+      objects: objects
+    };
+
+    if (type) {
+      data.type = type;
+    }
+
+    const result = await http.post('/sap/bc/z_abapgit_agent/view', data, { csrfToken });
+
+    // Handle uppercase keys from ABAP
+    const success = result.SUCCESS || result.success;
+    const viewObjects = 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 view objects'}`);
+      return;
+    }
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(`\n  ${message}`);
+      console.log('');
+
+      for (let i = 0; i < viewObjects.length; i++) {
+        const obj = viewObjects[i];
+        const objName = obj.NAME || obj.name || `Object ${i + 1}`;
+        const objType = obj.TYPE || obj.type || '';
+        const objTypeText = obj.TYPE_TEXT || obj.type_text || '';
+        const description = obj.DESCRIPTION || obj.description || '';
+        const methods = obj.METHODS || obj.methods || [];
+        const components = obj.COMPONENTS || obj.components || [];
+        const notFound = obj.NOT_FOUND || obj.not_found || false;
+
+        // Check if object was not found
+        if (notFound) {
+          console.log(`  ❌ ${objName} (${objTypeText})`);
+          console.log(`     Object not found: ${objName}`);
+          continue;
+        }
+
+        console.log(`  📖 ${objName} (${objTypeText})`);
+        if (description) {
+          console.log(`     ${description}`);
+        }
+
+        // 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' || objType === 'PROG' || objType === 'Program')) {
+          console.log('');
+          // Replace escaped newlines with actual newlines and display
+          const displaySource = source.replace(/\\n/g, '\n');
+          const lines = displaySource.split('\n');
+          for (const line of lines) {
+            console.log(`  ${line}`);
+          }
+        }
+
+        if (methods.length > 0) {
+          console.log(`     Methods: ${methods.length}`);
+          for (const method of methods.slice(0, 5)) {
+            const name = method.NAME || method.name || '';
+            const visibility = method.VISIBILITY || method.visibility || '';
+            console.log(`       - ${visibility} ${name}`);
+          }
+          if (methods.length > 5) {
+            console.log(`       ... and ${methods.length - 5} more`);
+          }
+        }
+
+        if (components.length > 0) {
+          // Check if this is a data element (DTEL) - show domain info in property format
+          if (objType === 'DTEL' || objType === 'Data Element') {
+            const propWidth = 18;
+            const valueWidth = 40;
+
+            // Build separator with corners
+            const sep = '┌' + '─'.repeat(propWidth + 2) + '┬' + '─'.repeat(valueWidth + 2) + '┐';
+            const mid = '├' + '─'.repeat(propWidth + 2) + '┼' + '─'.repeat(valueWidth + 2) + '┤';
+            const end = '└' + '─'.repeat(propWidth + 2) + '┴' + '─'.repeat(valueWidth + 2) + '┘';
+
+            // Helper to build row
+            const buildPropRow = (property, value) => {
+              return '│ ' + String(property || '').padEnd(propWidth) + ' │ ' +
+                     String(value || '').substring(0, valueWidth).padEnd(valueWidth) + ' │';
+            };
+
+            console.log(`  DATA ELEMENT ${objName}:`);
+            console.log(sep);
+            console.log(buildPropRow('Property', 'Value'));
+            console.log(mid);
+
+            // Collect properties from top-level fields and components
+            const domain = obj.DOMAIN || obj.domain || '';
+            const domainType = obj.DOMAIN_TYPE || obj.domain_type || '';
+            const domainLength = obj.DOMAIN_LENGTH || obj.domain_length || 0;
+            const domainDecimals = obj.DOMAIN_DECIMALS || obj.domain_decimals || 0;
+            const description = obj.DESCRIPTION || obj.description || '';
+
+            if (domainType) {
+              console.log(buildPropRow('Data Type', domainType));
+            }
+            if (domainLength) {
+              console.log(buildPropRow('Length', String(domainLength)));
+            }
+            if (domainDecimals) {
+              console.log(buildPropRow('Decimals', String(domainDecimals)));
+            }
+            if (description) {
+              console.log(buildPropRow('Description', description));
+            }
+            if (domain) {
+              console.log(buildPropRow('Domain', domain));
+            }
+
+            console.log(end);
+          } else if (objType === 'TTYP' || objType === 'Table Type') {
+            // Show TTYP details as simple text lines
+            console.log('');
+            for (const comp of components) {
+              const desc = comp.DESCRIPTION || comp.description || '';
+              if (desc) {
+                console.log(`   ${desc}`);
+              }
+            }
+          } else {
+            // Build table display for TABL/STRU with Data Element and Description
+            const colWidths = {
+              field: 16,      // Max field name length
+              key: 3,
+              type: 8,
+              length: 8,
+              dataelement: 30, // Max data element name length
+              description: 60, // Max field description length
+            };
+
+            // Helper to truncate with ellipsis if needed
+            const truncate = (str, maxLen) => {
+              const s = String(str || '');
+              if (s.length <= maxLen) return s;
+              return s.substring(0, maxLen - 1) + '…';
+            };
+
+            // Helper to build row
+            const buildRow = (field, key, type, length, dataelement, description) => {
+              return '  | ' + truncate(field, colWidths.field).padEnd(colWidths.field) + ' | ' + String(key || '').padEnd(colWidths.key) + ' | ' + truncate(type, colWidths.type).padEnd(colWidths.type) + ' | ' + String(length || '').padStart(colWidths.length) + ' | ' + truncate(dataelement, colWidths.dataelement).padEnd(colWidths.dataelement) + ' | ' + truncate(description, colWidths.description).padEnd(colWidths.description) + ' |';
+            };
+
+            // Build separator line (matches row structure with | at ends and + between columns)
+            const sep = '  |' + '-'.repeat(colWidths.field + 2) + '+' +
+                        '-'.repeat(colWidths.key + 2) + '+' +
+                        '-'.repeat(colWidths.type + 2) + '+' +
+                        '-'.repeat(colWidths.length + 2) + '+' +
+                        '-'.repeat(colWidths.dataelement + 2) + '+' +
+                        '-'.repeat(colWidths.description + 2) + '|';
+
+            // Header
+            console.log(`  TABLE ${objName}:`);
+            console.log(sep);
+            console.log(buildRow('Field', 'Key', 'Type', 'Length', 'Data Elem', 'Description'));
+            console.log(sep);
+
+            // Rows
+            for (const comp of components) {
+              const key = comp.KEY || comp.key || false ? 'X' : '';
+              const dataelement = comp.DATAELEMENT || comp.dataelement || '';
+              const description = comp.DESCRIPTION || comp.description || '';
+              console.log(buildRow(comp.FIELD || comp.field, key, comp.TYPE || comp.type, comp.LENGTH || comp.length, dataelement, description));
+            }
+
+            console.log(sep);
+          }
+        }
+
+        console.log('');
+      }
+    }
+  }
+};

package/src/commands/where.js

@@ -0,0 +1,138 @@
+/**
+ * Where command - Find where-used references for ABAP objects
+ */
+
+module.exports = {
+  name: 'where',
+  description: 'Find where-used references for ABAP objects',
+  requiresAbapConfig: true,
+  requiresVersionCheck: true,
+
+  async execute(args, context) {
+    const { loadConfig, AbapHttp } = context;
+
+    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>] [--offset <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');
+      console.error('Example: abapgit-agent where --objects CL_SUT_AUNIT_RUNNER --offset 100');
+      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 limitRaw = limitArg !== -1 ? args[limitArg + 1] : null;
+    const limitParsed = parseInt(limitRaw, 10);
+    const limit = limitRaw && !limitRaw.startsWith('--') && !isNaN(limitParsed) ? Math.max(1, limitParsed) : 100;
+    const offsetArg = args.indexOf('--offset');
+    const offsetRaw = offsetArg !== -1 ? args[offsetArg + 1] : null;
+    const offsetParsed = parseInt(offsetRaw, 10);
+    const offset = offsetRaw && !offsetRaw.startsWith('--') && !isNaN(offsetParsed) ? Math.max(0, offsetParsed) : 0;
+    const jsonOutput = args.includes('--json');
+
+    console.log(`\n  Where-used list for ${objects.length} object(s)`);
+
+    const config = loadConfig();
+    const http = new AbapHttp(config);
+    const csrfToken = await http.fetchCsrfToken();
+
+    const data = {
+      objects: objects,
+      limit: Math.min(Math.max(1, limit), 500),
+      offset: Math.max(0, offset)
+    };
+
+    if (type) {
+      data.type = type;
+    }
+
+    const result = await http.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;
+    const pagination = result.PAGINATION || result.pagination || null;
+
+    if (!success || error) {
+      console.error(`\n  Error: ${error || 'Failed to get where-used list'}`);
+      return;
+    }
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      // Build pagination message
+      let paginationMsg = '';
+      const paginationTotal = pagination.TOTAL || pagination.total || 0;
+      const paginationHasMore = pagination.HAS_MORE || pagination.has_more || false;
+      if (pagination && paginationTotal > 0) {
+        // Handle case where offset exceeds total
+        if (offset >= paginationTotal) {
+          paginationMsg = ` (Offset ${offset} exceeds total ${paginationTotal})`;
+        } else {
+          const start = offset + 1;
+          const end = Math.min(offset + limit, paginationTotal);
+          paginationMsg = ` (Showing ${start}-${end} of ${paginationTotal})`;
+          if (paginationHasMore) {
+            paginationMsg += ` — Use --offset ${offset + limit} to see more`;
+          }
+        }
+      }
+
+      console.log(`\n  ${message}${paginationMsg}`);
+      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('');
+      }
+    }
+  }
+};

package/src/config.js

@@ -65,9 +65,19 @@ function getTransport() {
   return cfg.transport;
 }
 
+/**
+ * Check if ABAP integration is configured for this repo
+ * @returns {boolean} True if .abapGitAgent file exists
+ */
+function isAbapIntegrationEnabled() {
+  const repoConfigPath = path.join(process.cwd(), '.abapGitAgent');
+  return fs.existsSync(repoConfigPath);
+}
+
 module.exports = {
   loadConfig,
   getAbapConfig,
   getAgentConfig,
-  getTransport
+  getTransport,
+  isAbapIntegrationEnabled
 };