abapgit-agent 1.7.1 → 1.8.0

package/src/commands/inspect.js

@@ -0,0 +1,184 @@
+/**
+ * Inspect command - Syntax check for ABAP files
+ */
+
+const pathModule = require('path');
+
+/**
+ * Inspect all files in one request
+ */
+async function inspectAllFiles(files, csrfToken, config, variant, http) {
+  // Convert files to uppercase names
+  const fileNames = files.map(f => {
+    const baseName = pathModule.basename(f).toUpperCase();
+    return baseName;
+  });
+
+  try {
+    // Send all files in one request
+    const data = {
+      files: fileNames
+    };
+
+    // Add variant if specified
+    if (variant) {
+      data.variant = variant;
+    }
+
+    const result = await http.post('/sap/bc/z_abapgit_agent/inspect', data, { csrfToken });
+
+    // Handle both table result and old single result
+    let results = [];
+    if (Array.isArray(result)) {
+      results = result;
+    } else {
+      // Convert single result to array format
+      results = [{
+        OBJECT_TYPE: 'UNKNOWN',
+        OBJECT_NAME: files.join(', '),
+        SUCCESS: result.SUCCESS !== undefined ? result.SUCCESS === 'X' || result.SUCCESS === true : result.success,
+        ERROR_COUNT: result.ERROR_COUNT || result.error_count || 0,
+        ERRORS: result.ERRORS || result.errors || [],
+        WARNINGS: result.warnings || []
+      }];
+    }
+
+    return results;
+  } catch (error) {
+    console.error(`\n  Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Process a single inspect result
+ */
+async function processInspectResult(res) {
+  // Handle both uppercase and lowercase keys
+  const success = res.SUCCESS !== undefined ? res.SUCCESS : res.success;
+  const objectType = res.OBJECT_TYPE !== undefined ? res.OBJECT_TYPE : res.object_type;
+  const objectName = res.OBJECT_NAME !== undefined ? res.OBJECT_NAME : res.object_name;
+  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 || infos.length > 0) {
+    if (errorCount > 0) {
+      console.log(`❌ ${objectType} ${objectName} - Syntax check failed (${errorCount} error(s)):`);
+    } else {
+      const total = warnings.length + infos.length;
+      console.log(`⚠️  ${objectType} ${objectName} - Syntax check passed with warnings (${total}):`);
+    }
+    console.log('\nErrors:');
+    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 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('');
+    }
+
+    // Show warnings if any
+    if (warnings.length > 0) {
+      console.log('Warnings:');
+      console.log('─'.repeat(60));
+      for (const warn of warnings) {
+        const line = warn.LINE || warn.line || '?';
+        const text = warn.MESSAGE || warn.message || 'Unknown warning';
+        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') {
+    console.log(`✅ ${objectType} ${objectName} - Syntax check passed`);
+  } else {
+    console.log(`⚠️  ${objectType} ${objectName} - Syntax check returned unexpected status`);
+  }
+}
+
+module.exports = {
+  name: 'inspect',
+  description: 'Inspect ABAP source files for syntax issues',
+  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 inspect --files <file1>,<file2>,... [--variant <check-variant>]');
+      console.error('Example: abapgit-agent inspect --files src/zcl_my_class.clas.abap');
+      console.error('Example: abapgit-agent inspect --files src/zcl_my_class.clas.abap --variant ALL_CHECKS');
+      process.exit(1);
+    }
+
+    const filesSyntaxCheck = args[filesArgIndex + 1].split(',').map(f => f.trim());
+
+    // Parse optional --variant parameter
+    const variantArgIndex = args.indexOf('--variant');
+    const variant = variantArgIndex !== -1 ? args[variantArgIndex + 1] : null;
+
+    console.log(`\n  Inspect for ${filesSyntaxCheck.length} file(s)`);
+    if (variant) {
+      console.log(`  Using variant: ${variant}`);
+    }
+    console.log('');
+
+    const config = loadConfig();
+    const http = new AbapHttp(config);
+    const csrfToken = await http.fetchCsrfToken();
+
+    // Send all files in one request
+    const results = await inspectAllFiles(filesSyntaxCheck, csrfToken, config, variant, http);
+
+    // Process results
+    for (const result of results) {
+      await processInspectResult(result);
+    }
+  }
+};

package/src/commands/list.js

@@ -0,0 +1,143 @@
+/**
+ * List command - List ABAP objects in a package
+ */
+
+module.exports = {
+  name: 'list',
+  description: 'List ABAP objects in a package',
+  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 list --package <package> [--type <types>] [--name <pattern>] [--limit <n>] [--offset <n>] [--json]');
+      console.error('Example: abapgit-agent list --package \'$ZMY_PACKAGE\'');
+      console.error('Example: abapgit-agent list --package \'$ZMY_PACKAGE\' --type CLAS,INTF');
+      process.exit(1);
+    }
+
+    // Check if package value is missing
+    if (packageArgIndex + 1 >= args.length) {
+      console.error('Error: --package parameter value is missing');
+      process.exit(1);
+    }
+
+    const packageName = args[packageArgIndex + 1];
+
+    // Validate package name
+    if (!packageName || packageName.trim() === '') {
+      console.error('Error: --package parameter cannot be empty');
+      process.exit(1);
+    }
+
+    // Optional type parameter
+    const typeArgIndex = args.indexOf('--type');
+    const type = typeArgIndex !== -1 && typeArgIndex + 1 < args.length ? args[typeArgIndex + 1] : null;
+
+    // Optional name pattern
+    const nameArgIndex = args.indexOf('--name');
+    const name = nameArgIndex !== -1 && nameArgIndex + 1 < args.length ? args[nameArgIndex + 1] : null;
+
+    // Optional limit
+    const limitArgIndex = args.indexOf('--limit');
+    let limit = 100;
+    if (limitArgIndex !== -1 && limitArgIndex + 1 < args.length) {
+      limit = parseInt(args[limitArgIndex + 1], 10);
+      if (isNaN(limit) || limit < 1) {
+        console.error('Error: --limit must be a positive number');
+        process.exit(1);
+      }
+      if (limit > 1000) {
+        console.error('Error: --limit value too high (max: 1000)');
+        process.exit(1);
+      }
+    }
+
+    // Optional offset
+    const offsetArgIndex = args.indexOf('--offset');
+    let offset = 0;
+    if (offsetArgIndex !== -1 && offsetArgIndex + 1 < args.length) {
+      offset = parseInt(args[offsetArgIndex + 1], 10);
+      if (isNaN(offset) || offset < 0) {
+        console.error('Error: --offset must be a non-negative number');
+        process.exit(1);
+      }
+    }
+
+    // Optional json parameter
+    const jsonOutput = args.includes('--json');
+
+    const config = loadConfig();
+    const http = new AbapHttp(config);
+    const csrfToken = await http.fetchCsrfToken();
+
+    const data = {
+      package: packageName,
+      limit: limit,
+      offset: offset
+    };
+
+    if (type) {
+      data.type = type;
+    }
+
+    if (name) {
+      data.name = name;
+    }
+
+    const result = await http.post('/sap/bc/z_abapgit_agent/list', data, { csrfToken });
+
+    // Handle uppercase keys from ABAP
+    const success = result.SUCCESS || result.success;
+    const error = result.ERROR || result.error;
+    const objects = result.OBJECTS || result.objects || [];
+    const byType = result.BY_TYPE || result.by_type || [];
+    const total = result.TOTAL || result.total || 0;
+
+    if (!success || error) {
+      console.error(`\n  Error: ${error || 'Failed to list objects'}`);
+      process.exit(1);
+    }
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      // Display human-readable output
+      let title = `Objects in ${packageName}`;
+      if (type) {
+        title += ` (${type} only`;
+        if (total !== objects.length) {
+          title += `, Total: ${total}`;
+        }
+        title += ')';
+      } else if (total !== objects.length) {
+        title += ` (Total: ${total})`;
+      }
+      console.log(`\n${title}\n`);
+
+      // Group objects by type
+      const objectsByType = {};
+      for (const obj of objects) {
+        const objType = (obj.TYPE || obj.type || '???').toUpperCase();
+        if (!objectsByType[objType]) {
+          objectsByType[objType] = [];
+        }
+        objectsByType[objType].push(obj.NAME || obj.name);
+      }
+
+      // Display grouped objects
+      for (const objType of Object.keys(objectsByType).sort()) {
+        const objNames = objectsByType[objType];
+        console.log(`  ${objType} (${objNames.length})`);
+        for (const objName of objNames) {
+          console.log(`    ${objName}`);
+        }
+        console.log('');
+      }
+    }
+  }
+};

package/src/commands/preview.js

@@ -0,0 +1,277 @@
+/**
+ * Preview command - Preview data from ABAP tables or CDS views
+ */
+
+module.exports = {
+  name: 'preview',
+  description: 'Preview data from ABAP tables or CDS views',
+  requiresAbapConfig: true,
+  requiresVersionCheck: true,
+
+  async execute(args, context) {
+    const { loadConfig, AbapHttp, validators } = context;
+
+    const objectsArgIndex = args.indexOf('--objects');
+    if (objectsArgIndex === -1 || objectsArgIndex + 1 >= args.length) {
+      console.error('Error: --objects parameter required');
+      console.error('Usage: abapgit-agent preview --objects <table1>,<view1>,... [--type <type>] [--limit <n>] [--offset <n>] [--where <condition>] [--columns <cols>] [--vertical] [--compact] [--json]');
+      console.error('Example: abapgit-agent preview --objects SFLIGHT');
+      console.error('Example: abapgit-agent preview --objects ZC_MY_CDS_VIEW --type DDLS');
+      console.error('Example: abapgit-agent preview --objects SFLIGHT --where "CARRID = \'AA\'"');
+      console.error('Example: abapgit-agent preview --objects SFLIGHT --offset 10 --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 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 whereArg = args.indexOf('--where');
+    const where = whereArg !== -1 ? args[whereArg + 1] : null;
+    const columnsArg = args.indexOf('--columns');
+    const columns = columnsArg !== -1 ? args[columnsArg + 1].split(',').map(c => c.trim().toUpperCase()) : null;
+    const verticalOutput = args.includes('--vertical');
+    const compactOutput = args.includes('--compact');
+    const jsonOutput = args.includes('--json');
+
+    console.log(`\n  Previewing ${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;
+    }
+
+    if (where) {
+      data.where = validators.convertDatesInWhereClause(where);
+    }
+
+    if (columns) {
+      data.columns = columns;
+    }
+
+    const result = await http.post('/sap/bc/z_abapgit_agent/preview', data, { csrfToken });
+
+    // Handle uppercase keys from ABAP
+    const success = result.SUCCESS || result.success;
+    const previewObjects = 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 preview objects'}`);
+      return;
+    }
+
+    const pagination = result.PAGINATION || result.pagination || null;
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      // Build pagination message
+      let paginationMsg = '';
+      const paginationTotal = pagination ? (pagination.TOTAL || pagination.total || 0) : 0;
+      const paginationHasMore = pagination ? (pagination.HAS_MORE || pagination.has_more || false) : 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('');
+
+      // Track if columns were explicitly specified
+      const columnsExplicit = columns !== null;
+
+      for (let i = 0; i < previewObjects.length; i++) {
+        const obj = previewObjects[i];
+        const objName = obj.NAME || obj.name || `Object ${i + 1}`;
+        const objType = obj.TYPE || obj.type || '';
+        const objTypeText = obj.TYPE_TEXT || obj.type_text || '';
+        // Parse rows - could be a JSON string or array
+        let rows = obj.ROWS || obj.rows || [];
+        if (typeof rows === 'string') {
+          try {
+            rows = JSON.parse(rows);
+          } catch (e) {
+            rows = [];
+          }
+        }
+        const fields = obj.FIELDS || obj.fields || [];
+        const rowCount = obj.ROW_COUNT || obj.row_count || 0;
+        const totalRows = obj.TOTAL_ROWS || obj.total_rows || 0;
+        const notFound = obj.NOT_FOUND || obj.not_found || false;
+        const accessDenied = obj.ACCESS_DENIED || obj.access_denied || false;
+
+        // Check if object was not found
+        if (notFound) {
+          console.log(`  ❌ ${objName} (${objTypeText})`);
+          console.log(`     Object not found: ${objName}`);
+          continue;
+        }
+
+        // Check if access denied
+        if (accessDenied) {
+          console.log(`  ❌ ${objName} (${objTypeText})`);
+          console.log(`     Access denied to: ${objName}`);
+          continue;
+        }
+
+        console.log(`  📊 Preview: ${objName} (${objTypeText})`);
+
+        // Check for errors first
+        const objError = obj.ERROR || obj.error;
+        if (objError) {
+          console.log(`     ❌ Error: ${objError}`);
+          continue;
+        }
+
+        if (rows.length === 0) {
+          console.log('     No data found');
+          continue;
+        }
+
+        // Get all unique field names from all rows
+        const allFields = new Set();
+        rows.forEach(row => {
+          Object.keys(row).forEach(key => allFields.add(key));
+        });
+        const allFieldNames = Array.from(allFields);
+
+        // Display as table - use fields metadata only if --columns was explicitly specified
+        let fieldNames;
+        let columnsAutoSelected = false;
+        if (columnsExplicit && fields && fields.length > 0) {
+          // Use fields from metadata (filtered by explicit --columns)
+          fieldNames = fields.map(f => f.FIELD || f.field);
+        } else {
+          // Use all fields - let terminal handle wrapping if needed
+          // Terminal width detection is unreliable without a proper TTY
+          fieldNames = allFieldNames;
+        }
+
+        // Calculate column widths - use reasonable defaults
+        const colWidths = {};
+        const maxColWidth = compactOutput ? 10 : 20;
+        fieldNames.forEach(field => {
+          let maxWidth = field.length;
+          rows.forEach(row => {
+            const value = String(row[field] || '');
+            maxWidth = Math.max(maxWidth, value.length);
+          });
+          // Cap at maxColWidth (truncates both headers and data in compact mode)
+          colWidths[field] = Math.min(maxWidth, maxColWidth);
+        });
+
+        // Render output - either vertical or table
+        if (verticalOutput) {
+          // Vertical format: each field on its own line
+          rows.forEach((row, rowIndex) => {
+            if (rows.length > 1) {
+              console.log(`\n  Row ${rowIndex + 1}:`);
+              console.log('  ' + '─'.repeat(30));
+            }
+            fieldNames.forEach(field => {
+              const value = String(row[field] || '');
+              console.log(`  ${field}: ${value}`);
+            });
+          });
+          console.log('');
+          continue;
+        }
+
+        // Build table header
+        let headerLine = '  ┌';
+        let separatorLine = '  ├';
+        fieldNames.forEach(field => {
+          const width = colWidths[field];
+          headerLine += '─'.repeat(width + 2) + '┬';
+          separatorLine += '─'.repeat(width + 2) + '┼';
+        });
+        headerLine = headerLine.slice(0, -1) + '┐';
+        separatorLine = separatorLine.slice(0, -1) + '┤';
+
+        // Build header row
+        let headerRow = '  │';
+        fieldNames.forEach(field => {
+          const width = colWidths[field];
+          let displayField = String(field);
+          if (displayField.length > width) {
+            displayField = displayField.slice(0, width - 3) + '...';
+          }
+          headerRow += ' ' + displayField.padEnd(width) + ' │';
+        });
+
+        console.log(headerLine);
+        console.log(headerRow);
+        console.log(separatorLine);
+
+        // Build data rows
+        rows.forEach(row => {
+          let dataRow = '  │';
+          fieldNames.forEach(field => {
+            const width = colWidths[field];
+            const value = String(row[field] || '');
+            const displayValue = value.length > width ? value.slice(0, width - 3) + '...' : value;
+            dataRow += ' ' + displayValue.padEnd(width) + ' │';
+          });
+          console.log(dataRow);
+        });
+
+        // Build bottom border
+        let bottomLine = '  └';
+        fieldNames.forEach(field => {
+          const width = colWidths[field];
+          bottomLine += '─'.repeat(width + 2) + '┴';
+        });
+        bottomLine = bottomLine.slice(0, -1) + '┘';
+        console.log(bottomLine);
+
+        // Show row count
+        if (totalRows > rowCount) {
+          console.log(`\n  Showing ${rowCount} of ${totalRows} rows`);
+        } else {
+          console.log(`\n  ${rowCount} row(s)`);
+        }
+
+        // Note about hidden columns only when --columns was explicitly specified
+        const columnsDisplayed = fieldNames.length;
+        let columnsHidden = [];
+
+        if (columnsExplicit) {
+          columnsHidden = obj.COLUMNS_HIDDEN || obj.columns_hidden || [];
+          if (columnsHidden.length > 0) {
+            console.log(`\n  ⚠️  ${columnsHidden.length} more columns hidden (${columnsHidden.join(', ')})`);
+            console.log('     Use --json for full data');
+          }
+        }
+
+        console.log('');
+      }
+    }
+  }
+};