abapgit-agent 1.5.0 → 1.6.1

package/bin/abapgit-agent

@@ -3,7 +3,8 @@
  * ABAP Git Agent - CLI Tool
  *
  * Usage:
- *   abapgit-agent init --folder <folder> --package <package>
+ *   abapgit-agent init --folder <folder> --package <package>  # Initialize: copies config, CLAUDE.md, guidelines
+ *   abapgit-agent init --update                               # Update existing files to latest version
  *   abapgit-agent create
  *   abapgit-agent import [--message <message>]
  *   abapgit-agent pull [--branch <branch>]
@@ -23,6 +24,27 @@ const TERM_WIDTH = getTermWidth();
 
 const COOKIE_FILE = '.abapgit_agent_cookies.txt';
 
+/**
+ * Convert ISO date formats (YYYY-MM-DD) to ABAP DATS format (YYYYMMDD) in WHERE clause
+ * This allows users to use familiar ISO date formats while ensuring compatibility with ABAP SQL
+ * @param {string} whereClause - SQL WHERE clause
+ * @returns {string} - WHERE clause with dates converted to YYYYMMDD format
+ */
+function convertDatesInWhereClause(whereClause) {
+  if (!whereClause) return whereClause;
+
+  // Pattern to match ISO date format: 'YYYY-MM-DD'
+  const isoDatePattern = /'\d{4}-\d{2}-\d{2}'/g;
+
+  return whereClause.replace(isoDatePattern, (match) => {
+    // Extract YYYY, MM, DD from 'YYYY-MM-DD'
+    const dateContent = match.slice(1, -1); // Remove quotes: YYYY-MM-DD
+    const [year, month, day] = dateContent.split('-');
+    // Return in ABAP format: 'YYYYMMDD'
+    return `'${year}${month}${day}'`;
+  });
+}
+
 /**
  * Get CLI version from package.json
  */
@@ -516,12 +538,14 @@ async function processInspectResult(res) {
   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) {
+  if (errorCount > 0 || warnings.length > 0 || infos.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}):`);
+      const total = warnings.length + infos.length;
+      console.log(`⚠️  ${objectType} ${objectName} - Syntax check passed with warnings (${total}):`);
     }
     console.log('\nErrors:');
     console.log('─'.repeat(60));
@@ -530,8 +554,16 @@ async function processInspectResult(res) {
       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('');
     }
@@ -543,7 +575,38 @@ async function processInspectResult(res) {
       for (const warn of warnings) {
         const line = warn.LINE || warn.line || '?';
         const text = warn.MESSAGE || warn.message || 'Unknown warning';
-        console.log(`  Line ${line}: ${text}`);
+        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') {
@@ -630,7 +693,7 @@ async function runUnitTests(options) {
 /**
  * Run unit test for a single file
  */
-async function runUnitTestForFile(sourceFile, csrfToken, config) {
+async function runUnitTestForFile(sourceFile, csrfToken, config, coverage = false) {
   console.log(`  Running unit test for: ${sourceFile}`);
 
   try {
@@ -665,7 +728,8 @@ async function runUnitTestForFile(sourceFile, csrfToken, config) {
 
     // Send files array to unit endpoint (ABAP expects string_table of file names)
     const data = {
-      files: [sourceFile]
+      files: [sourceFile],
+      coverage: coverage
     };
 
     const result = await request('POST', '/sap/bc/z_abapgit_agent/unit', data, { csrfToken });
@@ -678,6 +742,9 @@ async function runUnitTestForFile(sourceFile, csrfToken, config) {
     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) {
@@ -688,6 +755,17 @@ async function runUnitTestForFile(sourceFile, csrfToken, config) {
 
     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 || '?';
@@ -706,11 +784,11 @@ async function runUnitTestForFile(sourceFile, csrfToken, config) {
 /**
  * Run tree command and return raw result
  */
-async function runTreeCommand(packageName, depth, includeObjects, csrfToken, config) {
+async function runTreeCommand(packageName, depth, includeTypes, csrfToken, config) {
   const data = {
     package: packageName,
     depth: depth,
-    include_objects: includeObjects
+    include_objects: includeTypes
   };
 
   return await request('POST', '/sap/bc/z_abapgit_agent/tree', data, { csrfToken });
@@ -719,13 +797,13 @@ async function runTreeCommand(packageName, depth, includeObjects, csrfToken, con
 /**
  * Display tree output in human-readable format
  */
-async function displayTreeOutput(packageName, depth, includeObjects) {
+async function displayTreeOutput(packageName, depth, includeTypes) {
   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);
+  const result = await runTreeCommand(packageName, depth, includeTypes, csrfToken, config);
 
   // Handle uppercase keys from ABAP
   const success = result.SUCCESS || result.success;
@@ -765,7 +843,7 @@ async function displayTreeOutput(packageName, depth, includeObjects) {
   console.log(`  OBJECTS: ${totalObjects}`);
 
   // Display object types if available
-  if (includeObjects && objectTypes.length > 0) {
+  if (includeTypes && objectTypes.length > 0) {
     const typeStr = objectTypes.map(t => `${t.OBJECT || t.object}=${t.COUNT || t.count}`).join(' ');
     console.log(`  TYPES: ${typeStr}`);
   }
@@ -1068,12 +1146,86 @@ async function pull(gitUrl, branch = 'main', files = null, transportRequest = nu
   }
 }
 
+/**
+ * Copy a file if source exists (helper for init --update)
+ * @param {string} srcPath - Source file path
+ * @param {string} destPath - Destination file path
+ * @param {string} label - Label for console output
+ * @param {boolean} createParentDir - Whether to create parent directory
+ * @returns {Promise<void>}
+ */
+async function copyFileIfExists(srcPath, destPath, label, createParentDir = false) {
+  try {
+    if (fs.existsSync(srcPath)) {
+      if (createParentDir) {
+        const parentDir = pathModule.dirname(destPath);
+        if (!fs.existsSync(parentDir)) {
+          fs.mkdirSync(parentDir, { recursive: true });
+        }
+      }
+      fs.copyFileSync(srcPath, destPath);
+      console.log(`✅ Updated ${label}`);
+    } else {
+      console.log(`⚠️  ${label} not found in abapgit-agent`);
+    }
+  } catch (error) {
+    console.error(`Error copying ${label}: ${error.message}`);
+  }
+}
+
+/**
+ * Copy guidelines folder (helper for init --update)
+ * @param {string} srcPath - Source folder path
+ * @param {string} destPath - Destination folder path
+ * @param {boolean} overwrite - Whether to overwrite existing files
+ * @returns {Promise<void>}
+ */
+async function copyGuidelinesFolder(srcPath, destPath, overwrite = false) {
+  try {
+    if (fs.existsSync(srcPath)) {
+      // Create destination directory if needed
+      if (!fs.existsSync(destPath)) {
+        fs.mkdirSync(destPath, { recursive: true });
+      }
+
+      const files = fs.readdirSync(srcPath);
+      let copied = 0;
+
+      for (const file of files) {
+        if (file.endsWith('.md')) {
+          const srcFile = pathModule.join(srcPath, file);
+          const destFile = pathModule.join(destPath, file);
+
+          // Skip if file exists and not overwriting
+          if (fs.existsSync(destFile) && !overwrite) {
+            continue;
+          }
+
+          fs.copyFileSync(srcFile, destFile);
+          copied++;
+        }
+      }
+
+      if (copied > 0) {
+        console.log(`✅ Updated guidelines/ (${copied} files)`);
+      } else {
+        console.log(`⚠️  No guideline files found`);
+      }
+    } else {
+      console.log(`⚠️  guidelines folder not found in abapgit-agent`);
+    }
+  } catch (error) {
+    console.error(`Error copying guidelines: ${error.message}`);
+  }
+}
+
 /**
  * Run init command - Initialize local configuration
  */
 async function runInit(args) {
   const folderArgIndex = args.indexOf('--folder');
   const packageArgIndex = args.indexOf('--package');
+  const updateMode = args.includes('--update');
 
   // Get parameters
   const folder = folderArgIndex !== -1 && folderArgIndex + 1 < args.length
@@ -1084,18 +1236,14 @@ async function runInit(args) {
     ? args[packageArgIndex + 1]
     : null;
 
-  // Validate package is required
-  if (!packageName) {
+  // Validate package is required for non-update mode
+  if (!updateMode && !packageName) {
     console.error('Error: --package is required');
     console.error('Usage: abapgit-agent init --folder /src --package ZMY_PACKAGE');
+    console.error('       abapgit-agent init --update    # Update files to latest version');
     process.exit(1);
   }
 
-  console.log(`\n🚀 Initializing abapGit Agent for local repository`);
-  console.log(`   Folder: ${folder}`);
-  console.log(`   Package: ${packageName}`);
-  console.log('');
-
   // Check if current folder is git repo root
   const gitDir = pathModule.join(process.cwd(), '.git');
   if (!fs.existsSync(gitDir)) {
@@ -1104,6 +1252,53 @@ async function runInit(args) {
     process.exit(1);
   }
 
+  // In update mode, just copy the files and return
+  if (updateMode) {
+    console.log(`\n🔄 Updating abapGit Agent files`);
+    console.log('');
+
+    // Copy CLAUDE.md
+    await copyFileIfExists(
+      pathModule.join(__dirname, '..', 'abap', 'CLAUDE.md'),
+      pathModule.join(process.cwd(), 'CLAUDE.md'),
+      'CLAUDE.md'
+    );
+
+    // Copy copilot-instructions.md
+    await copyFileIfExists(
+      pathModule.join(__dirname, '..', 'abap', '.github', 'copilot-instructions.md'),
+      pathModule.join(process.cwd(), '.github', 'copilot-instructions.md'),
+      '.github/copilot-instructions.md',
+      true  // create parent dir
+    );
+
+    // Copy guidelines folder to project root
+    await copyGuidelinesFolder(
+      pathModule.join(__dirname, '..', 'abap', 'guidelines'),
+      pathModule.join(process.cwd(), 'guidelines'),
+      true  // overwrite
+    );
+
+    console.log(`
+📋 Update complete!
+   Run 'abapgit-agent ref --list-topics' to see available topics.
+`);
+    return;
+  }
+
+  // Validate package is required
+  if (!packageName) {
+    console.error('Error: --package is required');
+    console.error('Usage: abapgit-agent init --folder /src --package ZMY_PACKAGE');
+    console.error('       abapgit-agent init --update    # Update files to latest version');
+    process.exit(1);
+  }
+
+  console.log(`\n🚀 Initializing abapGit Agent for local repository`);
+  console.log(`   Folder: ${folder}`);
+  console.log(`   Package: ${packageName}`);
+  console.log('');
+
   // Detect git remote URL
   const gitUrl = getGitRemoteUrl();
   if (!gitUrl) {
@@ -1188,7 +1383,7 @@ async function runInit(args) {
   }
 
   // Copy copilot-instructions.md for GitHub Copilot
-  const copilotMdPath = pathModule.join(__dirname, '..', 'abap', 'copilot-instructions.md');
+  const copilotMdPath = pathModule.join(__dirname, '..', 'abap', '.github', 'copilot-instructions.md');
   const githubDir = pathModule.join(process.cwd(), '.github');
   const localCopilotMdPath = pathModule.join(githubDir, 'copilot-instructions.md');
   try {
@@ -1206,6 +1401,35 @@ async function runInit(args) {
     console.error(`Error copying copilot-instructions.md: ${error.message}`);
   }
 
+  // Copy guidelines folder to project root
+  const guidelinesSrcPath = pathModule.join(__dirname, '..', 'abap', 'guidelines');
+  const guidelinesDestPath = pathModule.join(process.cwd(), 'guidelines');
+  try {
+    if (fs.existsSync(guidelinesSrcPath)) {
+      if (!fs.existsSync(guidelinesDestPath)) {
+        // Create guidelines directory
+        fs.mkdirSync(guidelinesDestPath, { recursive: true });
+        // Copy all files from guidelines folder
+        const files = fs.readdirSync(guidelinesSrcPath);
+        for (const file of files) {
+          if (file.endsWith('.md')) {
+            fs.copyFileSync(
+              pathModule.join(guidelinesSrcPath, file),
+              pathModule.join(guidelinesDestPath, file)
+            );
+          }
+        }
+        console.log(`✅ Created guidelines/ (${files.filter(f => f.endsWith('.md')).length} files)`);
+      } else {
+        console.log(`⚠️  guidelines/ already exists, skipped`);
+      }
+    } else {
+      console.log(`⚠️  guidelines folder not found in abap/ directory`);
+    }
+  } catch (error) {
+    console.error(`Error copying guidelines: ${error.message}`);
+  }
+
   // Create folder
   const folderPath = pathModule.join(process.cwd(), folder);
   try {
@@ -1253,8 +1477,9 @@ async function main() {
   const command = args[0];
 
   // Check if ABAP integration is enabled for this repo
-  // (skip for init, help commands)
-  if (command && command !== 'init' && command !== 'help' && command !== '--help' && command !== '-h') {
+  // (skip for init, help, ref commands - these don't need ABAP connection)
+  const noAbapRequired = ['init', 'help', '--help', '-h', 'ref'];
+  if (command && !noAbapRequired.includes(command)) {
     if (!isAbapIntegrationEnabled()) {
       console.log(`
 ⚠️  ABAP Git Agent not configured for this repository.
@@ -1278,7 +1503,7 @@ To enable integration:
   }
 
   // Version compatibility check for commands that interact with ABAP
-  const abapCommands = ['create', 'import', 'pull', 'inspect', 'unit', 'tree', 'view', 'preview'];
+  const abapCommands = ['create', 'import', 'pull', 'inspect', 'unit', 'tree', 'view', 'preview', 'list'];
   if (command && abapCommands.includes(command)) {
     await checkVersionCompatibility();
   }
@@ -1558,21 +1783,25 @@ Examples:
         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>,...');
+          console.error('Usage: abapgit-agent unit --files <file1>,<file2>,... [--coverage]');
           console.error('Example: abapgit-agent unit --files zcl_my_test.clas.abap');
+          console.error('Example: abapgit-agent unit --files zcl_my_test.clas.abap --coverage');
           process.exit(1);
         }
 
         const files = args[filesArgIndex + 1].split(',').map(f => f.trim());
 
-        console.log(`\n  Running unit tests for ${files.length} file(s)`);
+        // 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 csrfToken = await fetchCsrfToken(config);
 
         for (const sourceFile of files) {
-          await runUnitTestForFile(sourceFile, csrfToken, config);
+          await runUnitTestForFile(sourceFile, csrfToken, config, coverage);
         }
         break;
       }
@@ -1581,7 +1810,7 @@ Examples:
         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-objects] [--json]');
+          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);
         }
@@ -1595,7 +1824,7 @@ Examples:
           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-objects] [--json]');
+          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);
         }
@@ -1605,7 +1834,7 @@ Examples:
         // 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-objects] [--json]');
+          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);
         }
@@ -1621,8 +1850,8 @@ Examples:
           }
         }
 
-        // Optional include-objects parameter
-        const includeObjects = args.includes('--include-objects');
+        // 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');
@@ -1630,10 +1859,141 @@ Examples:
         if (jsonOutput) {
           const config = loadConfig();
           const csrfToken = await fetchCsrfToken(config);
-          const result = await runTreeCommand(packageName, depth, includeObjects, csrfToken, config);
+          const result = await runTreeCommand(packageName, depth, includeTypes, csrfToken, config);
           console.log(JSON.stringify(result, null, 2));
         } else {
-          await displayTreeOutput(packageName, depth, includeObjects);
+          await displayTreeOutput(packageName, depth, includeTypes);
+        }
+        break;
+      }
+
+      case 'list': {
+        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 csrfToken = await fetchCsrfToken(config);
+
+        const data = {
+          package: packageName,
+          limit: limit,
+          offset: offset
+        };
+
+        if (type) {
+          data.type = type;
+        }
+
+        if (name) {
+          data.name = name;
+        }
+
+        const result = await request('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('');
+          }
         }
         break;
       }
@@ -1881,7 +2241,7 @@ Examples:
         }
 
         if (where) {
-          data.where = where;
+          data.where = convertDatesInWhereClause(where);
         }
 
         if (columns) {
@@ -2079,6 +2439,87 @@ Examples:
         break;
       }
 
+      case 'ref': {
+        const refSearch = require('../src/ref-search');
+        const topicIndex = args.indexOf('--topic');
+        const listTopics = args.includes('--list-topics') || args.includes('-l');
+        const listRepos = args.includes('--list-repos') || args.includes('-r');
+        const exportGuidelines = args.includes('--export') || args.includes('-e');
+        const jsonOutput = args.includes('--json');
+
+        if (exportGuidelines) {
+          const result = await refSearch.exportGuidelines();
+          if (jsonOutput) {
+            console.log(JSON.stringify(result, null, 2));
+          } else {
+            refSearch.displayExportResult(result);
+          }
+          break;
+        }
+
+        if (listRepos) {
+          const result = await refSearch.listRepositories();
+          if (jsonOutput) {
+            console.log(JSON.stringify(result, null, 2));
+          } else {
+            refSearch.displayRepositories(result);
+          }
+          break;
+        }
+
+        if (listTopics) {
+          const result = await refSearch.listTopics();
+          if (jsonOutput) {
+            console.log(JSON.stringify(result, null, 2));
+          } else {
+            refSearch.displayTopics(result);
+          }
+          break;
+        }
+
+        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);
+          }
+          break;
+        }
+
+        // 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 --export            Export local guidelines to reference folder');
+          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 --export');
+          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);
+        }
+        break;
+      }
+
       case 'help':
       case '--help':
       case '-h':
@@ -2091,6 +2532,8 @@ Usage:
 Commands:
   init --folder <folder> --package <package>
     Initialize local configuration for an existing git repository.
+  init --update
+    Update existing files (CLAUDE.md, copilot-instructions.md, guidelines) to latest version.
 
   create
     Create abapGit online repository in ABAP system.
@@ -2112,12 +2555,30 @@ Commands:
   unit --files <file1>,<file2>,...
     Run AUnit tests for ABAP test class files (.testclasses.abap)
 
-  tree --package <package> [--depth <n>] [--include-objects] [--json]
+  tree --package <package> [--depth <n>] [--include-types] [--json]
     Display package hierarchy tree from ABAP system
 
+  list --package <package> [--type <types>] [--name <pattern>] [--limit <n>] [--offset <n>] [--json]
+    List ABAP objects in a package with filtering and pagination
+
   view --objects <obj1>,<obj2>,... [--type <type>] [--json]
     View ABAP object definitions from the ABAP system
 
+  ref <pattern> [--json]
+    Search ABAP reference repositories for patterns. Requires referenceFolder in .abapGitAgent.
+
+  ref --topic <topic> [--json]
+    View specific topic from cheat sheets (exceptions, sql, unit-tests, etc.)
+
+  ref --list-topics
+    List available topics for reference search
+
+  ref --list-repos
+    List all reference repositories in the reference folder
+
+  ref --export
+    Export custom guidelines (abap/guidelines/) to reference folder
+
   health
     Check if ABAP REST API is healthy
 
@@ -2126,6 +2587,7 @@ Commands:
 
 Examples:
   abapgit-agent init --folder /src --package ZMY_PACKAGE      # Initialize
+  abapgit-agent init --update                                # Update files to latest
   abapgit-agent create                                       # Create repo
   abapgit-agent import                                       # Import objects to git
   abapgit-agent import --message "Initial import"            # Import with message
@@ -2135,14 +2597,27 @@ 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 tree --package \$ZMY_PACKAGE                      # Show package tree
+  abapgit-agent tree --package \$ZMY_PACKAGE --depth 2             # Shallow tree
+  abapgit-agent tree --package \$ZMY_PACKAGE --include-types      # With type counts
+  abapgit-agent tree --package \$ZMY_PACKAGE --json                # JSON output
+  abapgit-agent list --package $ZMY_PACKAGE                      # List all objects
+  abapgit-agent list --package $ZMY_PACKAGE --type CLAS,INTF      # Filter by type
+  abapgit-agent list --package $ZMY_PACKAGE --name ZCL_*         # Filter by name
+  abapgit-agent list --package $ZMY_PACKAGE --limit 50            # Limit results
+  abapgit-agent list --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 ref "CORRESPONDING"                         # Search all reference repos
+  abapgit-agent ref "CX_SY_"                                 # Search exceptions
+  abapgit-agent ref --topic exceptions                       # View exception topic
+  abapgit-agent ref --topic sql                              # View SQL topic
+  abapgit-agent ref --topic unit-tests                       # View unit test topic
+  abapgit-agent ref --list-topics                            # List all topics
+  abapgit-agent ref --list-repos                             # List reference repositories
+  abapgit-agent ref --export                                  # Export custom guidelines
   abapgit-agent health
   abapgit-agent status
 `);