abapgit-agent 1.7.2 → 1.8.1

package/src/commands/ref.js

@@ -0,0 +1,96 @@
+/**
+ * Ref command - Search ABAP reference materials (cheat sheets and guidelines)
+ */
+
+module.exports = {
+  name: 'ref',
+  description: 'Search ABAP reference materials',
+  requiresAbapConfig: false,
+  requiresVersionCheck: false,
+
+  async execute(args, context) {
+    const refSearch = require('../utils/abap-reference');
+
+    const topicIndex = args.indexOf('--topic');
+    const cloneIndex = args.indexOf('--clone');
+    const nameIndex = args.indexOf('--name');
+    const listTopics = args.includes('--list-topics') || args.includes('-l');
+    const listRepos = args.includes('--list-repos') || args.includes('-r');
+    const jsonOutput = args.includes('--json');
+
+    // Handle --clone option
+    if (cloneIndex !== -1 && cloneIndex + 1 < args.length) {
+      const repoUrl = args[cloneIndex + 1];
+      const name = nameIndex !== -1 && nameIndex + 1 < args.length ? args[nameIndex + 1] : null;
+      const result = refSearch.cloneRepository(repoUrl, name);
+      if (jsonOutput) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        refSearch.displayCloneResult(result);
+      }
+      return;
+    }
+
+    if (listRepos) {
+      const result = await refSearch.listRepositories();
+      if (jsonOutput) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        refSearch.displayRepositories(result);
+      }
+      return;
+    }
+
+    if (listTopics) {
+      const result = await refSearch.listTopics();
+      if (jsonOutput) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        refSearch.displayTopics(result);
+      }
+      return;
+    }
+
+    if (topicIndex !== -1 && topicIndex + 1 < args.length) {
+      const topic = args[topicIndex + 1];
+      const result = await refSearch.getTopic(topic);
+      if (jsonOutput) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        refSearch.displayTopic(result);
+      }
+      return;
+    }
+
+    // Pattern search (default)
+    const patternIndex = args.findIndex((arg, idx) => idx > 0 && !arg.startsWith('--'));
+    if (patternIndex === -1) {
+      console.error('Error: No pattern specified');
+      console.error('');
+      console.error('Usage:');
+      console.error('  abapgit-agent ref <pattern>           Search for pattern');
+      console.error('  abapgit-agent ref --topic <name>      View specific topic');
+      console.error('  abapgit-agent ref --list-topics       List available topics');
+      console.error('  abapgit-agent ref --list-repos       List reference repositories');
+      console.error('  abapgit-agent ref --clone <repo>     Clone a repository');
+      console.error('');
+      console.error('Examples:');
+      console.error('  abapgit-agent ref "CORRESPONDING"');
+      console.error('  abapgit-agent ref --topic exceptions');
+      console.error('  abapgit-agent ref --list-topics');
+      console.error('  abapgit-agent ref --list-repos');
+      console.error('  abapgit-agent ref --clone SAP-samples/abap-cheat-sheets');
+      console.error('  abapgit-agent ref --clone https://github.com/abapGit/abapGit.git');
+      process.exit(1);
+    }
+
+    const pattern = args[patternIndex];
+    const result = await refSearch.searchPattern(pattern);
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      refSearch.displaySearchResults(result);
+    }
+  }
+};

package/src/commands/status.js

@@ -0,0 +1,52 @@
+/**
+ * Status command - Check if ABAP integration is configured
+ */
+
+const pathModule = require('path');
+
+module.exports = {
+  name: 'status',
+  description: 'Check if ABAP integration is configured for this repo',
+  requiresAbapConfig: false,  // We check manually in execute
+  requiresVersionCheck: false,
+
+  async execute(args, context) {
+    const { gitUtils, isAbapIntegrationEnabled, AbapHttp, loadConfig } = context;
+
+    if (isAbapIntegrationEnabled()) {
+      console.log('✅ ABAP Git Agent is ENABLED');
+      console.log('   Config location:', pathModule.join(process.cwd(), '.abapGitAgent'));
+
+      // Check if repo exists in ABAP
+      const config = loadConfig();
+      const repoUrl = gitUtils.getRemoteUrl();
+
+      if (repoUrl) {
+        try {
+          const http = new AbapHttp(config);
+          const csrfToken = await http.fetchCsrfToken();
+          const result = await http.post('/sap/bc/z_abapgit_agent/status', { url: repoUrl }, { csrfToken });
+
+          const status = result.status || result.STATUS || result.SUCCESS;
+          if (status === 'Found' || status === 'X' || status === true) {
+            console.log('   Repository: ✅ Created');
+            const pkg = result.package || result.PACKAGE || 'N/A';
+            const key = result.key || result.KEY || result.REPO_KEY || result.repo_key || 'N/A';
+            console.log(`      Package: ${pkg}`);
+            console.log(`      URL: ${repoUrl}`);
+            console.log(`      Key: ${key}`);
+          } else {
+            console.log('   Repository: ❌ Not created');
+            console.log('      Run "abapgit-agent create" to create it');
+          }
+        } catch (error) {
+          console.log('   Repository: ❓ Unknown (could not check)');
+          console.log(`      Error: ${error.message}`);
+        }
+      }
+    } else {
+      console.log('❌ ABAP Git Agent is NOT configured');
+      console.log('   Run "abapgit-agent init" to set up configuration');
+    }
+  }
+};

package/src/commands/syntax.js

@@ -0,0 +1,340 @@
+/**
+ * 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();
+      } else if (baseName.includes('.ddls.asddls')) {
+        objType = 'DDLS';
+        objName = baseName.split('.')[0].toUpperCase();
+        fileKind = 'main';
+      }
+
+      // 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 {
+        const obj = {
+          type: objType,
+          name: objName,
+          source: source
+        };
+
+        // Read FIXPT from XML metadata for INTF and PROG
+        if (objType === 'INTF' || objType === 'PROG') {
+          const dir = pathModule.dirname(filePath);
+          let xmlFile;
+          if (objType === 'INTF') {
+            xmlFile = pathModule.join(dir, `${objName.toLowerCase()}.intf.xml`);
+          } else if (objType === 'PROG') {
+            xmlFile = pathModule.join(dir, `${objName.toLowerCase()}.prog.xml`);
+          }
+          if (xmlFile && fs.existsSync(xmlFile)) {
+            const xmlContent = fs.readFileSync(xmlFile, 'utf8');
+            // Simple regex to extract FIXPT value
+            const fixptMatch = xmlContent.match(/<FIXPT>([^<]+)<\/FIXPT>/);
+            if (fixptMatch && fixptMatch[1] === 'X') {
+              obj.fixpt = 'X';
+            } else {
+              // No FIXPT tag means FIXPT=false (blank)
+              obj.fixpt = '';
+            }
+          }
+        }
+
+        objects.push(obj);
+      }
+    }
+
+    // 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;
+
+        // Read FIXPT from XML metadata
+        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 xmlFile = pathModule.join(dir, `${className.toLowerCase()}.clas.xml`);
+          if (fs.existsSync(xmlFile)) {
+            const xmlContent = fs.readFileSync(xmlFile, 'utf8');
+            // Simple regex to extract FIXPT value
+            const fixptMatch = xmlContent.match(/<FIXPT>([^<]+)<\/FIXPT>/);
+            if (fixptMatch && fixptMatch[1] === 'X') {
+              obj.fixpt = 'X';
+            } else {
+              // No FIXPT tag means FIXPT=false (blank)
+              obj.fixpt = '';
+            }
+          }
+        }
+
+        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);
+    }
+  }
+};