abapgit-agent 1.1.6 → 1.3.0

package/bin/abapgit-agent

@@ -309,33 +309,70 @@ async function syntaxCheckSource(sourceFile, csrfToken, config) {
 
     const result = await request('POST', '/sap/bc/z_abapgit_agent/inspect', data, { csrfToken: csrfToken });
 
-    // Handle uppercase keys from ABAP - handle both 'X'/true (success) and false
-    const success = result.SUCCESS !== undefined ? result.SUCCESS : (result.success !== undefined ? result.success : null);
-    const errorCount = result.ERROR_COUNT || result.error_count || 0;
-    const errors = result.ERRORS || result.errors || [];
+    // Handle new table-based result format (array) or old single result
+    let results = [];
+    if (Array.isArray(result)) {
+      results = result;
+    } else {
+      // Convert old single result to array format for compatibility
+      results = [{
+        OBJECT_TYPE: 'UNKNOWN',
+        OBJECT_NAME: pathModule.basename(sourceFile),
+        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 || []
+      }];
+    }
 
-    console.log('\n');
+    // Process each result
+    let hasErrors = false;
+    for (const res of results) {
+      // 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 || []);
+
+      console.log('\n');
+
+      if (errorCount > 0 || warnings.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}):`);
+        }
+        console.log('\nErrors:');
+        console.log('─'.repeat(60));
 
-    if (errorCount > 0) {
-      console.log(`❌ Syntax check failed (${errorCount} error(s)):`);
-      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';
 
-      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';
+          console.log(`  Line ${line}, Column ${column}:`);
+          console.log(`    ${text}`);
+          console.log('');
+        }
 
-        console.log(`  Line ${line}, Column ${column}:`);
-        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';
+            console.log(`  Line ${line}: ${text}`);
+          }
+        }
+        hasErrors = true;
+      } else if (success === true || success === 'X') {
+        console.log(`✅ ${objectType} ${objectName} - Syntax check passed`);
+      } else {
+        console.log(`⚠️  ${objectType} ${objectName} - Syntax check returned unexpected status`);
       }
-    } else if (success === 'X' || success === true) {
-      console.log(`✅ ${pathModule.basename(sourceFile)} - Syntax check passed (0 errors)`);
-    } else if (success === false) {
-      console.log(`❌ ${pathModule.basename(sourceFile)} - Syntax check failed`);
-    } else {
-      console.log(`⚠️  Syntax check returned unexpected status: ${success}`);
     }
 
     return result;
@@ -345,6 +382,95 @@ async function syntaxCheckSource(sourceFile, csrfToken, config) {
   }
 }
 
+/**
+ * Inspect all files in one request
+ */
+async function inspectAllFiles(files, csrfToken, config) {
+  // Convert files to uppercase names (same as syntaxCheckSource does)
+  const fileNames = files.map(f => {
+    const baseName = pathModule.basename(f).toUpperCase();
+    return baseName;
+  });
+
+  try {
+    // Send all files in one request
+    const data = {
+      files: fileNames
+    };
+
+    const result = await request('POST', '/sap/bc/z_abapgit_agent/inspect', data, { csrfToken: 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 || []);
+
+  if (errorCount > 0 || warnings.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}):`);
+    }
+    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';
+
+      console.log(`  Line ${line}, Column ${column}:`);
+      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';
+        console.log(`  Line ${line}: ${text}`);
+      }
+    }
+  } else if (success === true || success === 'X') {
+    console.log(`✅ ${objectType} ${objectName} - Syntax check passed`);
+  } else {
+    console.log(`⚠️  ${objectType} ${objectName} - Syntax check returned unexpected status`);
+  }
+}
+
 /**
  * Run unit tests for package or objects
  */
@@ -495,6 +621,136 @@ async function runUnitTestForFile(sourceFile, csrfToken, config) {
   }
 }
 
+/**
+ * Run tree command and return raw result
+ */
+async function runTreeCommand(packageName, depth, includeObjects, csrfToken, config) {
+  const data = {
+    package: packageName,
+    depth: depth,
+    include_objects: includeObjects
+  };
+
+  return await request('POST', '/sap/bc/z_abapgit_agent/tree', data, { csrfToken });
+}
+
+/**
+ * Display tree output in human-readable format
+ */
+async function displayTreeOutput(packageName, depth, includeObjects) {
+  const config = loadConfig();
+  const csrfToken = await fetchCsrfToken(config);
+
+  console.log(`\n  Getting package tree for: ${packageName}`);
+
+  const result = await runTreeCommand(packageName, depth, includeObjects, csrfToken, config);
+
+  // 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 (includeObjects && objectTypes.length > 0) {
+    const typeStr = objectTypes.map(t => `${t.OBJECT || t.object}=${t.COUNT || t.count}`).join(' ');
+    console.log(`  TYPES: ${typeStr}`);
+  }
+}
+
+/**
+ * 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 ? '   ' : '│  ');
+
+  for (let i = 0; i < depth1.length; i++) {
+    const child = depth1[i];
+    const isSubLast = i === depth1.length - 1;
+    const childLines = buildChildLines(child, newPrefix, isSubLast, byDepth);
+    lines.push(...childLines);
+  }
+
+  return lines;
+}
+
+function buildChildLines(node, prefix, isLast, byDepth) {
+  const lines = [];
+  const icon = '📦';
+  lines.push(`${prefix}${isLast ? '└─ ' : '├─ '} ${icon} ${node.PACKAGE || node.package}`);
+
+  const newPrefix = prefix + (isLast ? '   ' : '│  ');
+  const nodeDepth = node.DEPTH || node.depth;
+  const children = byDepth[nodeDepth + 1] || [];
+
+  // Find children of this node
+  const myChildren = children.filter(n => (n.PARENT || n.parent) === (node.PACKAGE || node.package));
+
+  for (let i = 0; i < myChildren.length; i++) {
+    const child = myChildren[i];
+    const isSubLast = i === myChildren.length - 1;
+    const childLines = buildChildLines(child, newPrefix, isSubLast, byDepth);
+    lines.push(...childLines);
+  }
+
+  return lines;
+}
+
 /**
  * Pull and activate repository
  */
@@ -561,7 +817,46 @@ async function pull(gitUrl, branch = 'main', files = null, transportRequest = nu
         'W': '⚠️',  // Warning
         'A': '🛑'   // Abort
       };
-      return icons[type] || '  ';
+      return icons[type] || '';
+    };
+
+    // Calculate display width accounting for emoji (2 cells) vs ASCII (1 cell)
+    const calcWidth = (str) => {
+      if (!str) return 0;
+      let width = 0;
+      let i = 0;
+      while (i < str.length) {
+        const code = str.codePointAt(i);
+        if (!code) break;
+        // Variation selectors (FE00-FE0F) and ZWJ (200D) take 0 width
+        if (code >= 0xFE00 && code <= 0xFE0F) {
+          i += 1;
+          continue;
+        }
+        if (code === 0x200D) {  // Zero width joiner
+          i += 1;
+          continue;
+        }
+        // Emoji and wide characters take 2 cells
+        if (code > 0xFFFF) {
+          width += 2;
+          i += 2;  // Skip surrogate pair
+        } else if (code > 127) {
+          width += 2;
+          i += 1;
+        } else {
+          width += 1;
+          i += 1;
+        }
+      }
+      return width;
+    };
+
+    // Pad string to display width
+    const padToWidth = (str, width) => {
+      const s = str || '';
+      const currentWidth = calcWidth(s);
+      return s + ' '.repeat(Math.max(0, width - currentWidth));
     };
 
     if (success === 'X' || success === true) {
@@ -589,23 +884,15 @@ async function pull(gitUrl, branch = 'main', files = null, transportRequest = nu
 
       // Calculate column widths based on terminal width
       const tableWidth = Math.min(TERM_WIDTH, 120);
-      const iconCol = 5;  // Width for emoji column (emoji takes 2 visual cells)
+      const iconCol = 4;  // Fixed width for icon column
       const objCol = 28;
       const msgCol = tableWidth - iconCol - objCol - 6; // Account for vertical lines (3 chars)
 
-      // Helper to get visible width (emoji takes 2 cells)
-      const getVisibleWidth = (str) => {
-        let width = 0;
-        for (const char of str) {
-          width += (char.charCodeAt(0) > 127) ? 2 : 1;  // Emoji/wide chars = 2
-        }
-        return width;
-      };
-
-      // Helper to pad to visible width
+      // Pad string to display width using calcWidth for emoji support
       const padToWidth = (str, width) => {
-        const currentWidth = getVisibleWidth(str);
-        return str + ' '.repeat(width - currentWidth);
+        const s = str || '';
+        const currentWidth = calcWidth(s);
+        return s + ' '.repeat(Math.max(0, width - currentWidth));
       };
 
       const headerLine = '─'.repeat(iconCol) + '┼' + '─'.repeat(objCol) + '┼' + '─'.repeat(msgCol);
@@ -818,6 +1105,25 @@ async function runInit(args) {
     console.error(`Error copying CLAUDE.md: ${error.message}`);
   }
 
+  // Copy copilot-instructions.md for GitHub Copilot
+  const copilotMdPath = pathModule.join(__dirname, '..', 'abap', 'copilot-instructions.md');
+  const githubDir = pathModule.join(process.cwd(), '.github');
+  const localCopilotMdPath = pathModule.join(githubDir, 'copilot-instructions.md');
+  try {
+    if (fs.existsSync(copilotMdPath)) {
+      // Ensure .github directory exists
+      if (!fs.existsSync(githubDir)) {
+        fs.mkdirSync(githubDir, { recursive: true });
+      }
+      fs.copyFileSync(copilotMdPath, localCopilotMdPath);
+      console.log(`✅ Created .github/copilot-instructions.md`);
+    } else {
+      console.log(`⚠️  copilot-instructions.md not found in abap/ directory`);
+    }
+  } catch (error) {
+    console.error(`Error copying copilot-instructions.md: ${error.message}`);
+  }
+
   // Create folder
   const folderPath = pathModule.join(process.cwd(), folder);
   try {
@@ -1144,8 +1450,12 @@ Examples:
         const config = loadConfig();
         const csrfToken = await fetchCsrfToken(config);
 
-        for (const sourceFile of filesSyntaxCheck) {
-          await syntaxCheckSource(sourceFile, csrfToken, config);
+        // Send all files in one request
+        const results = await inspectAllFiles(filesSyntaxCheck, csrfToken, config);
+
+        // Process results
+        for (const result of results) {
+          await processInspectResult(result);
         }
         break;
       }
@@ -1173,6 +1483,249 @@ Examples:
         break;
       }
 
+      case 'tree': {
+        const packageArgIndex = args.indexOf('--package');
+        if (packageArgIndex === -1 || packageArgIndex + 1 >= args.length) {
+          console.error('Error: --package parameter required');
+          console.error('Usage: abapgit-agent tree --package <package> [--depth <n>] [--include-objects] [--json]');
+          console.error('Example: abapgit-agent tree --package $ZMY_PACKAGE');
+          process.exit(1);
+        }
+
+        const packageName = args[packageArgIndex + 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-objects parameter
+        const includeObjects = 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, includeObjects, csrfToken, config);
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          await displayTreeOutput(packageName, depth, includeObjects);
+        }
+        break;
+      }
+
+      case 'view': {
+        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 csrfToken = await fetchCsrfToken(config);
+
+        const data = {
+          objects: objects
+        };
+
+        if (type) {
+          data.type = type;
+        }
+
+        const result = await request('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'}`);
+          break;
+        }
+
+        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, and CDS views
+            const source = obj.SOURCE || obj.source || '';
+            if (source && (objType === 'INTF' || objType === 'Interface' || objType === 'CLAS' || objType === 'Class' || objType === 'DDLS' || objType === 'CDS View')) {
+              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('');
+          }
+
+        }
+        break;
+      }
+
       case 'help':
       case '--help':
       case '-h':
@@ -1206,6 +1759,12 @@ Commands:
   unit --files <file1>,<file2>,...
     Run AUnit tests for ABAP test class files (.testclasses.abap)
 
+  tree --package <package> [--depth <n>] [--include-objects] [--json]
+    Display package hierarchy tree from ABAP system
+
+  view --objects <obj1>,<obj2>,... [--type <type>] [--json]
+    View ABAP object definitions from the ABAP system
+
   health
     Check if ABAP REST API is healthy
 
@@ -1223,6 +1782,14 @@ Examples:
   abapgit-agent pull --transport DEVK900001                  # With transport
   abapgit-agent inspect --files zcl_my_class.clas.abap       # Syntax check
   abapgit-agent unit --files zcl_my_test.clas.testclasses.abap  # Run tests
+  abapgit-agent tree --package $ZMY_PACKAGE                      # Show package tree
+  abapgit-agent tree --package $ZMY_PACKAGE --depth 2             # Shallow tree
+  abapgit-agent tree --package $ZMY_PACKAGE --include-objects     # With object counts
+  abapgit-agent tree --package $ZMY_PACKAGE --json                # JSON output
+  abapgit-agent view --objects ZCL_MY_CLASS                       # View class definition
+  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 health
   abapgit-agent status
 `);