abapgit-agent 1.7.1 → 1.8.0

package/src/commands/syntax.js

@@ -0,0 +1,290 @@
+/**
+ * Syntax command - Check syntax of ABAP source files directly (without pull/activation)
+ */
+
+const pathModule = require('path');
+const fs = require('fs');
+
+module.exports = {
+  name: 'syntax',
+  description: 'Check syntax of ABAP source files without pull/activation',
+  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 syntax --files <file1>,<file2>,... [--cloud] [--json]');
+      console.error('');
+      console.error('Options:');
+      console.error('  --cloud         Use ABAP Cloud syntax check (stricter)');
+      console.error('  --json          Output raw JSON');
+      console.error('');
+      console.error('Examples:');
+      console.error('  abapgit-agent syntax --files src/zcl_my_class.clas.abap');
+      console.error('  abapgit-agent syntax --files src/zcl_my_class.clas.abap --cloud');
+      process.exit(1);
+    }
+
+    const syntaxFiles = args[filesArgIndex + 1].split(',').map(f => f.trim());
+    const cloudMode = args.includes('--cloud');
+    const jsonOutput = args.includes('--json');
+
+    if (!jsonOutput) {
+      console.log(`\n  Syntax check for ${syntaxFiles.length} file(s)`);
+      if (cloudMode) {
+        console.log('  Mode: ABAP Cloud');
+      }
+      console.log('');
+    }
+
+    const config = loadConfig();
+    const http = new AbapHttp(config);
+    const csrfToken = await http.fetchCsrfToken();
+
+    // Build objects array from files
+    // Group class files together (main + locals)
+    const classFilesMap = new Map(); // className -> { main, locals_def, locals_imp }
+    const objects = [];
+
+    for (const file of syntaxFiles) {
+      const baseName = pathModule.basename(file);
+      let objType = 'PROG';
+      let objName = baseName.toUpperCase();
+      let fileKind = 'main'; // main, locals_def, locals_imp
+
+      // Parse file type from extension
+      if (baseName.includes('.clas.locals_def.')) {
+        objType = 'CLAS';
+        objName = baseName.split('.')[0].toUpperCase();
+        fileKind = 'locals_def';
+      } else if (baseName.includes('.clas.locals_imp.')) {
+        objType = 'CLAS';
+        objName = baseName.split('.')[0].toUpperCase();
+        fileKind = 'locals_imp';
+      } else if (baseName.includes('.clas.testclasses.')) {
+        objType = 'CLAS';
+        objName = baseName.split('.')[0].toUpperCase();
+        fileKind = 'locals_imp';  // Test classes are implementations
+      } else if (baseName.includes('.clas.')) {
+        objType = 'CLAS';
+        objName = baseName.split('.')[0].toUpperCase();
+        fileKind = 'main';
+      } else if (baseName.includes('.intf.')) {
+        objType = 'INTF';
+        objName = baseName.split('.')[0].toUpperCase();
+      } else if (baseName.includes('.prog.')) {
+        objType = 'PROG';
+        objName = baseName.split('.')[0].toUpperCase();
+      }
+
+      // Read source from file
+      const filePath = pathModule.resolve(file);
+      if (!fs.existsSync(filePath)) {
+        console.error(`  Error: File not found: ${file}`);
+        continue;
+      }
+
+      const source = fs.readFileSync(filePath, 'utf8');
+
+      // For class files, group them together
+      if (objType === 'CLAS') {
+        if (!classFilesMap.has(objName)) {
+          classFilesMap.set(objName, { main: null, locals_def: null, locals_imp: null, testclasses: null });
+        }
+        const classFiles = classFilesMap.get(objName);
+        // For testclasses, store in testclasses field (not locals_imp)
+        if (fileKind === 'locals_imp' && baseName.includes('.testclasses.')) {
+          classFiles.testclasses = source;
+        } else {
+          classFiles[fileKind] = source;
+        }
+      } else {
+        objects.push({
+          type: objType,
+          name: objName,
+          source: source
+        });
+      }
+    }
+
+    // Add class objects with their local files
+    for (const [className, files] of classFilesMap) {
+      // Try to auto-detect companion files if only one type is provided
+      if (files.main && !files.locals_def && !files.locals_imp && !files.testclasses) {
+        // Main file provided - look for companion local files
+        const mainFile = syntaxFiles.find(f => {
+          const bn = pathModule.basename(f).toUpperCase();
+          return bn.startsWith(className) && bn.includes('.CLAS.ABAP') && !bn.includes('LOCALS') && !bn.includes('TESTCLASSES');
+        });
+        if (mainFile) {
+          const dir = pathModule.dirname(mainFile);
+          const defFile = pathModule.join(dir, `${className.toLowerCase()}.clas.locals_def.abap`);
+          const impFile = pathModule.join(dir, `${className.toLowerCase()}.clas.locals_imp.abap`);
+          const testFile = pathModule.join(dir, `${className.toLowerCase()}.clas.testclasses.abap`);
+          if (fs.existsSync(defFile)) {
+            files.locals_def = fs.readFileSync(defFile, 'utf8');
+            if (!jsonOutput) console.log(`  Auto-detected: ${pathModule.basename(defFile)}`);
+          }
+          if (fs.existsSync(impFile)) {
+            files.locals_imp = fs.readFileSync(impFile, 'utf8');
+            if (!jsonOutput) console.log(`  Auto-detected: ${pathModule.basename(impFile)}`);
+          }
+          if (fs.existsSync(testFile)) {
+            files.testclasses = fs.readFileSync(testFile, 'utf8');
+            if (!jsonOutput) console.log(`  Auto-detected: ${pathModule.basename(testFile)}`);
+          }
+        }
+      } else if (!files.main && (files.locals_def || files.locals_imp || files.testclasses)) {
+        // Any local file provided - look for main class file and other companions
+        const localFile = syntaxFiles.find(f => {
+          const bn = pathModule.basename(f).toUpperCase();
+          return bn.startsWith(className) && (bn.includes('.LOCALS_') || bn.includes('.TESTCLASSES.'));
+        });
+        if (localFile) {
+          const dir = pathModule.dirname(localFile);
+          const mainFile = pathModule.join(dir, `${className.toLowerCase()}.clas.abap`);
+          const defFile = pathModule.join(dir, `${className.toLowerCase()}.clas.locals_def.abap`);
+          const impFile = pathModule.join(dir, `${className.toLowerCase()}.clas.locals_imp.abap`);
+          const testFile = pathModule.join(dir, `${className.toLowerCase()}.clas.testclasses.abap`);
+
+          if (fs.existsSync(mainFile)) {
+            files.main = fs.readFileSync(mainFile, 'utf8');
+            if (!jsonOutput) console.log(`  Auto-detected: ${pathModule.basename(mainFile)}`);
+          }
+          // Also auto-detect other companion files
+          if (!files.locals_def && fs.existsSync(defFile)) {
+            files.locals_def = fs.readFileSync(defFile, 'utf8');
+            if (!jsonOutput) console.log(`  Auto-detected: ${pathModule.basename(defFile)}`);
+          }
+          if (!files.locals_imp && fs.existsSync(impFile)) {
+            files.locals_imp = fs.readFileSync(impFile, 'utf8');
+            if (!jsonOutput) console.log(`  Auto-detected: ${pathModule.basename(impFile)}`);
+          }
+          if (!files.testclasses && fs.existsSync(testFile)) {
+            files.testclasses = fs.readFileSync(testFile, 'utf8');
+            if (!jsonOutput) console.log(`  Auto-detected: ${pathModule.basename(testFile)}`);
+          }
+        }
+      }
+
+      if (files.main) {
+        const obj = {
+          type: 'CLAS',
+          name: className,
+          source: files.main
+        };
+        if (files.locals_def) obj.locals_def = files.locals_def;
+        if (files.locals_imp) obj.locals_imp = files.locals_imp;
+        if (files.testclasses) obj.testclasses = files.testclasses;
+        objects.push(obj);
+      } else {
+        console.error(`  Warning: No main class file for ${className}, skipping local files`);
+      }
+    }
+
+    if (objects.length === 0) {
+      console.error('  No valid files to check');
+      process.exit(1);
+    }
+
+    // Send request
+    const data = {
+      objects: objects,
+      uccheck: cloudMode ? '5' : 'X'
+    };
+
+    const result = await http.post('/sap/bc/z_abapgit_agent/syntax', data, { csrfToken });
+
+    // Handle response
+    const success = result.SUCCESS !== undefined ? result.SUCCESS : result.success;
+    const results = result.RESULTS || result.results || [];
+    const message = result.MESSAGE || result.message || '';
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      // Display results for each object
+      for (const res of results) {
+        const objSuccess = res.SUCCESS !== undefined ? res.SUCCESS : res.success;
+        const objType = res.OBJECT_TYPE || res.object_type || 'UNKNOWN';
+        const objName = res.OBJECT_NAME || res.object_name || 'UNKNOWN';
+        const errorCount = res.ERROR_COUNT || res.error_count || 0;
+        const errors = res.ERRORS || res.errors || [];
+        const warnings = res.WARNINGS || res.warnings || [];
+        const objMessage = res.MESSAGE || res.message || '';
+
+        if (objSuccess) {
+          console.log(`✅ ${objType} ${objName} - Syntax check passed`);
+          if (warnings.length > 0) {
+            console.log(`   (${warnings.length} warning(s))`);
+          }
+        } else {
+          console.log(`❌ ${objType} ${objName} - Syntax check failed (${errorCount} error(s))`);
+          console.log('');
+          console.log('Errors:');
+          console.log('─'.repeat(60));
+
+          for (const err of errors) {
+            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 include = err.INCLUDE || err.include || '';
+
+            // Display which file/include the error is in
+            if (include) {
+              const includeMap = {
+                'main': { display: 'Main class', suffix: '.clas.abap' },
+                'locals_def': { display: 'Local definitions', suffix: '.clas.locals_def.abap' },
+                'locals_imp': { display: 'Local implementations', suffix: '.clas.locals_imp.abap' },
+                'testclasses': { display: 'Test classes', suffix: '.clas.testclasses.abap' }
+              };
+              const includeInfo = includeMap[include] || { display: include, suffix: '' };
+
+              // Show both display name and filename
+              if (includeInfo.suffix) {
+                console.log(`  In: ${includeInfo.display} (${objName.toLowerCase()}${includeInfo.suffix})`);
+              } else {
+                console.log(`  In: ${includeInfo.display}`);
+              }
+            }
+            if (methodName) {
+              console.log(`  Method: ${methodName}`);
+            }
+            if (column) {
+              console.log(`  Line ${line}, Column ${column}:`);
+            } else {
+              console.log(`  Line ${line}:`);
+            }
+            console.log(`    ${text}`);
+            console.log('');
+          }
+        }
+
+        // Show warnings if any
+        if (warnings.length > 0) {
+          console.log('');
+          console.log('Warnings:');
+          console.log('─'.repeat(60));
+          for (const warn of warnings) {
+            const line = warn.LINE || warn.line || '?';
+            const text = warn.TEXT || warn.text || warn.MESSAGE || warn.message || '';
+            console.log(`  Line ${line}: ${text}`);
+          }
+        }
+        console.log('');
+      }
+
+      // Overall summary
+      if (success) {
+        console.log(`✅ ${message}`);
+      } else {
+        console.log(`❌ ${message}`);
+      }
+    }
+  }
+};

package/src/commands/tree.js

@@ -0,0 +1,209 @@
+/**
+ * Tree command - Display package hierarchy tree
+ */
+
+/**
+ * Run tree command and return raw result
+ */
+async function runTreeCommand(packageName, depth, includeTypes, csrfToken, http) {
+  const data = {
+    package: packageName,
+    depth: depth,
+    include_objects: includeTypes
+  };
+
+  return await http.post('/sap/bc/z_abapgit_agent/tree', data, { csrfToken });
+}
+
+/**
+ * Build tree display lines from flat nodes list
+ */
+function buildTreeLinesFromNodes(nodes, prefix, isLast) {
+  const lines = [];
+
+  if (nodes.length === 0) {
+    return lines;
+  }
+
+  // First node is the root
+  const root = nodes[0];
+  const icon = '📦';
+  lines.push(`${prefix}${isLast ? '└─ ' : '├─ '} ${icon} ${root.PACKAGE || root.package}`);
+
+  // Get children (nodes with depth > 0, grouped by depth)
+  const children = nodes.filter(n => (n.DEPTH || n.depth) > 0);
+
+  // Group children by depth
+  const byDepth = {};
+  children.forEach(n => {
+    const d = n.DEPTH || n.depth;
+    if (!byDepth[d]) byDepth[d] = [];
+    byDepth[d].push(n);
+  });
+
+  // Process depth 1 children
+  const depth1 = byDepth[1] || [];
+  const newPrefix = prefix + (isLast ? '   ' : '│  ');
+
+  depth1.forEach((child, idx) => {
+    const childIsLast = idx === depth1.length - 1;
+    const childLines = buildChildLines(child, newPrefix, childIsLast, byDepth);
+    lines.push(...childLines);
+  });
+
+  return lines;
+}
+
+/**
+ * Build lines for child nodes recursively
+ */
+function buildChildLines(node, prefix, isLast, byDepth) {
+  const lines = [];
+  const icon = '📦';
+  const pkg = node.PACKAGE || node.package;
+
+  lines.push(`${prefix}${isLast ? '└─ ' : '├─ '} ${icon} ${pkg}`);
+
+  // Get children of this node
+  const nodeDepth = node.DEPTH || node.depth;
+  const children = (byDepth[nodeDepth + 1] || []).filter(n => {
+    const parent = n.PARENT || n.parent;
+    return parent === pkg;
+  });
+
+  const newPrefix = prefix + (isLast ? '   ' : '│  ');
+
+  children.forEach((child, idx) => {
+    const childIsLast = idx === children.length - 1;
+    const childLines = buildChildLines(child, newPrefix, childIsLast, byDepth);
+    lines.push(...childLines);
+  });
+
+  return lines;
+}
+
+/**
+ * Display tree output
+ */
+async function displayTreeOutput(packageName, depth, includeTypes, loadConfig, AbapHttp) {
+  const config = loadConfig();
+  const http = new AbapHttp(config);
+
+  const csrfToken = await http.fetchCsrfToken();
+
+  console.log(`\n  Getting package tree for: ${packageName}`);
+
+  const result = await runTreeCommand(packageName, depth, includeTypes, csrfToken, http);
+
+  // Handle uppercase keys from ABAP
+  const success = result.SUCCESS || result.success;
+  const error = result.ERROR || result.error;
+
+  if (!success || error) {
+    console.error(`\n  ❌ Error: ${error || 'Failed to get tree'}`);
+    return;
+  }
+
+  // Parse hierarchy structure (ABAP returns flat nodes with parent refs)
+  const nodes = result.NODES || result.nodes || [];
+  const rootPackage = result.PACKAGE || result.package || packageName;
+  const parentPackage = result.PARENT_PACKAGE || result.parent_package;
+  const totalPackages = result.TOTAL_PACKAGES || result.total_packages || 0;
+  const totalObjects = result.TOTAL_OBJECTS || result.total_objects || 0;
+  const objectTypes = result.OBJECTS || result.objects || [];
+
+  console.log(`\n  Package Tree: ${rootPackage}`);
+
+  // Display parent info if available
+  if (parentPackage && parentPackage !== rootPackage) {
+    console.log(`  ⬆️  Parent: ${parentPackage}`);
+  }
+
+  console.log('');
+
+  // Build and display tree from flat nodes list
+  const lines = buildTreeLinesFromNodes(nodes, '', true);
+  for (const line of lines) {
+    console.log(`  ${line}`);
+  }
+
+  console.log('');
+  console.log('  Summary');
+  console.log(`  PACKAGES: ${totalPackages}`);
+  console.log(`  OBJECTS: ${totalObjects}`);
+
+  // Display object types if available
+  if (includeTypes && objectTypes.length > 0) {
+    const typeStr = objectTypes.map(t => `${t.OBJECT || t.object}=${t.COUNT || t.count}`).join(' ');
+    console.log(`  TYPES: ${typeStr}`);
+  }
+}
+
+module.exports = {
+  name: 'tree',
+  description: 'Display package hierarchy tree from ABAP system',
+  requiresAbapConfig: true,
+  requiresVersionCheck: true,
+
+  async execute(args, context) {
+    const { loadConfig, AbapHttp } = context;
+
+    const packageArgIndex = args.indexOf('--package');
+    if (packageArgIndex === -1) {
+      console.error('Error: --package parameter required');
+      console.error('Usage: abapgit-agent tree --package <package> [--depth <n>] [--include-types] [--json]');
+      console.error('Example: abapgit-agent tree --package ZMY_PACKAGE');
+      process.exit(1);
+    }
+
+    // Check if package value is missing (happens when shell variable expands to empty)
+    if (packageArgIndex + 1 >= args.length) {
+      console.error('Error: --package parameter value is missing');
+      console.error('');
+      console.error('Tip: If you are using a shell variable, make sure to quote it:');
+      console.error('  abapgit-agent tree --package \'$ZMY_PACKAGE\'');
+      console.error('  or escape the $ character:');
+      console.error('  abapgit-agent tree --package \\$ZMY_PACKAGE');
+      console.error('');
+      console.error('Usage: abapgit-agent tree --package <package> [--depth <n>] [--include-types] [--json]');
+      console.error('Example: abapgit-agent tree --package ZMY_PACKAGE');
+      process.exit(1);
+    }
+
+    const packageName = args[packageArgIndex + 1];
+
+    // Check for empty/whitespace-only package name
+    if (!packageName || packageName.trim() === '') {
+      console.error('Error: --package parameter cannot be empty');
+      console.error('Usage: abapgit-agent tree --package <package> [--depth <n>] [--include-types] [--json]');
+      console.error('Example: abapgit-agent tree --package ZMY_PACKAGE');
+      process.exit(1);
+    }
+
+    // Optional depth parameter
+    const depthArgIndex = args.indexOf('--depth');
+    let depth = 3;
+    if (depthArgIndex !== -1 && depthArgIndex + 1 < args.length) {
+      depth = parseInt(args[depthArgIndex + 1], 10);
+      if (isNaN(depth) || depth < 1) {
+        console.error('Error: --depth must be a positive number');
+        process.exit(1);
+      }
+    }
+
+    // Optional include-types parameter (--include-objects is deprecated alias)
+    const includeTypes = args.includes('--include-types') || args.includes('--include-objects');
+
+    // Optional json parameter
+    const jsonOutput = args.includes('--json');
+
+    if (jsonOutput) {
+      const config = loadConfig();
+      const csrfToken = await fetchCsrfToken(config);
+      const result = await runTreeCommand(packageName, depth, includeTypes, csrfToken, request);
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      await displayTreeOutput(packageName, depth, includeTypes, loadConfig, AbapHttp);
+    }
+  }
+};

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);
+    }
+  }
+};