abapgit-agent 1.4.0 → 1.6.0

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,95 @@ 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
+ */
+function getCliVersion() {
+  const packageJsonPath = pathModule.join(__dirname, '..', 'package.json');
+  if (fs.existsSync(packageJsonPath)) {
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    return pkg.version || '1.0.0';
+  }
+  return '1.0.0';
+}
+
+/**
+ * Check version compatibility between CLI and ABAP API
+ */
+async function checkVersionCompatibility() {
+  const cliVersion = getCliVersion();
+
+  try {
+    const config = loadConfig();
+    const https = require('https');
+    const url = new URL(`/sap/bc/z_abapgit_agent/health`, `https://${config.host}:${config.sapport}`);
+
+    return new Promise((resolve) => {
+      const options = {
+        hostname: url.hostname,
+        port: url.port,
+        path: url.pathname,
+        method: 'GET',
+        headers: {
+          'Authorization': `Basic ${Buffer.from(`${config.user}:${config.password}`).toString('base64')}`,
+          'sap-client': config.client,
+          'sap-language': config.language || 'EN',
+          'Content-Type': 'application/json'
+        },
+        agent: new https.Agent({ rejectUnauthorized: false })
+      };
+
+      const req = https.request(options, (res) => {
+        let body = '';
+        res.on('data', chunk => body += chunk);
+        res.on('end', () => {
+          try {
+            const result = JSON.parse(body);
+            const apiVersion = result.version || '1.0.0';
+
+            if (cliVersion !== apiVersion) {
+              console.log(`\n⚠️  Version mismatch: CLI ${cliVersion}, ABAP API ${apiVersion}`);
+              console.log('   Some commands may not work correctly.');
+              console.log('   Update ABAP code: abapgit-agent pull\n');
+            }
+            resolve({ cliVersion, apiVersion, compatible: cliVersion === apiVersion });
+          } catch (e) {
+            resolve({ cliVersion, apiVersion: null, compatible: false, error: e.message });
+          }
+        });
+      });
+
+      req.on('error', (e) => {
+        resolve({ cliVersion, apiVersion: null, compatible: false, error: e.message });
+      });
+      req.end();
+    });
+  } catch (error) {
+    return { cliVersion, apiVersion: null, compatible: false, error: error.message };
+  }
+}
+
 /**
  * Load configuration from .abapGitAgent in current working directory
  */
@@ -42,10 +132,19 @@ function loadConfig() {
     password: process.env.ABAP_PASSWORD,
     language: process.env.ABAP_LANGUAGE || 'EN',
     gitUsername: process.env.GIT_USERNAME,
-    gitPassword: process.env.GIT_PASSWORD
+    gitPassword: process.env.GIT_PASSWORD,
+    transport: process.env.ABAP_TRANSPORT
   };
 }
 
+/**
+ * Get transport request from config or environment
+ */
+function getTransport() {
+  const config = loadConfig();
+  return config.transport;
+}
+
 /**
  * Check if ABAP integration is configured for this repo
  */
@@ -385,7 +484,7 @@ async function syntaxCheckSource(sourceFile, csrfToken, config) {
 /**
  * Inspect all files in one request
  */
-async function inspectAllFiles(files, csrfToken, config) {
+async function inspectAllFiles(files, csrfToken, config, variant = null) {
   // Convert files to uppercase names (same as syntaxCheckSource does)
   const fileNames = files.map(f => {
     const baseName = pathModule.basename(f).toUpperCase();
@@ -398,6 +497,11 @@ async function inspectAllFiles(files, csrfToken, config) {
       files: fileNames
     };
 
+    // Add variant if specified
+    if (variant) {
+      data.variant = variant;
+    }
+
     const result = await request('POST', '/sap/bc/z_abapgit_agent/inspect', data, { csrfToken: csrfToken });
 
     // Handle both table result and old single result
@@ -624,11 +728,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 });
@@ -637,13 +741,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;
@@ -683,7 +787,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}`);
   }
@@ -986,12 +1090,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
@@ -1002,18 +1180,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)) {
@@ -1022,6 +1196,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) {
@@ -1106,7 +1327,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 {
@@ -1124,6 +1345,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 {
@@ -1171,8 +1421,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.
@@ -1195,6 +1446,12 @@ To enable integration:
     }
   }
 
+  // Version compatibility check for commands that interact with ABAP
+  const abapCommands = ['create', 'import', 'pull', 'inspect', 'unit', 'tree', 'view', 'preview', 'list'];
+  if (command && abapCommands.includes(command)) {
+    await checkVersionCompatibility();
+  }
+
   try {
     switch (command) {
       case 'init':
@@ -1390,16 +1647,21 @@ Examples:
         let gitUrl = urlArgIndex !== -1 ? args[urlArgIndex + 1] : null;
         let branch = branchArgIndex !== -1 ? args[branchArgIndex + 1] : getGitBranch();
         let files = null;
+
+        // Transport: CLI arg takes priority, then config/environment, then null
         let transportRequest = null;
+        if (transportArgIndex !== -1 && transportArgIndex + 1 < args.length) {
+          // Explicit --transport argument
+          transportRequest = args[transportArgIndex + 1];
+        } else {
+          // Fall back to config or environment variable
+          transportRequest = getTransport();
+        }
 
         if (filesArgIndex !== -1 && filesArgIndex + 1 < args.length) {
           files = args[filesArgIndex + 1].split(',').map(f => f.trim());
         }
 
-        if (transportArgIndex !== -1 && transportArgIndex + 1 < args.length) {
-          transportRequest = args[transportArgIndex + 1];
-        }
-
         if (!gitUrl) {
           gitUrl = getGitRemoteUrl();
           if (!gitUrl) {
@@ -1427,31 +1689,32 @@ Examples:
         break;
 
       case 'inspect': {
-        // TODO: Implement full inspect feature with:
-        // - Syntax check (currently implemented via /inspect)
-        // - Code Inspector checks (SE51, SCI)
-        // - ATC checks (SATC)
-        // - Custom rule checks
-        // Add --check-type parameter to specify which check to run
-
         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>,...');
+          console.error('Usage: abapgit-agent inspect --files <file1>,<file2>,... [--variant <check-variant>]');
           console.error('Example: abapgit-agent inspect --files zcl_my_class.clas.abap');
+          console.error('Example: abapgit-agent inspect --files 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 csrfToken = await fetchCsrfToken(config);
 
         // Send all files in one request
-        const results = await inspectAllFiles(filesSyntaxCheck, csrfToken, config);
+        const results = await inspectAllFiles(filesSyntaxCheck, csrfToken, config, variant);
 
         // Process results
         for (const result of results) {
@@ -1485,15 +1748,37 @@ Examples:
 
       case 'tree': {
         const packageArgIndex = args.indexOf('--package');
-        if (packageArgIndex === -1 || packageArgIndex + 1 >= args.length) {
+        if (packageArgIndex === -1) {
           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');
+          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;
@@ -1505,8 +1790,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');
@@ -1514,10 +1799,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;
       }
@@ -1765,7 +2181,7 @@ Examples:
         }
 
         if (where) {
-          data.where = where;
+          data.where = convertDatesInWhereClause(where);
         }
 
         if (columns) {
@@ -1963,6 +2379,109 @@ 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);
+
+        // Also search guidelines if available
+        const guidelinesResult = await refSearch.searchGuidelines(pattern);
+        if (guidelinesResult && guidelinesResult.guidelinesFound && guidelinesResult.matches.length > 0) {
+          result.guidelines = guidelinesResult;
+        }
+
+        if (jsonOutput) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          refSearch.displaySearchResults(result);
+          // Display guidelines results if found
+          if (guidelinesResult && guidelinesResult.guidelinesFound && guidelinesResult.matches.length > 0) {
+            console.log('\n  📋 Custom Guidelines:');
+            for (const match of guidelinesResult.matches.slice(0, 5)) {
+              console.log(`    📄 ${match.file} (line ${match.line}):`);
+              const lines = match.context.split('\n');
+              lines.forEach((line, idx) => {
+                const prefix = idx === 1 ? '  → ' : '    ';
+                const trimmed = line.slice(0, 80);
+                console.log(`${prefix}${trimmed}`);
+              });
+            }
+            if (guidelinesResult.matches.length > 5) {
+              console.log(`    ... and ${guidelinesResult.matches.length - 5} more matches`);
+            }
+          }
+        }
+        break;
+      }
+
       case 'help':
       case '--help':
       case '-h':
@@ -1975,6 +2494,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.
@@ -1996,12 +2517,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
 
@@ -2010,6 +2549,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
@@ -2019,14 +2559,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
 `);