abapgit-agent 1.7.2 → 1.8.0

package/src/commands/import.js

@@ -0,0 +1,99 @@
+/**
+ * Import command - Import existing objects from package to git repository
+ */
+
+module.exports = {
+  name: 'import',
+  description: 'Import existing objects from package to git repository',
+  requiresAbapConfig: true,
+  requiresVersionCheck: true,
+
+  async execute(args, context) {
+    const { loadConfig, gitUtils, AbapHttp } = context;
+
+    // Show help if requested
+    const helpIndex = args.findIndex(a => a === '--help' || a === '-h');
+    if (helpIndex !== -1) {
+      console.log(`
+Usage:
+  abapgit-agent import [--message <message>]
+
+Description:
+  Import existing objects from package to git repository.
+  Uses the git remote URL to find the abapGit online repository.
+
+Prerequisites:
+  - Run "abapgit-agent create" first or create repository in abapGit UI
+  - Package must have objects to import
+
+Options:
+  --message    Commit message (default: "feat: initial import from ABAP package <package>")
+
+Examples:
+  abapgit-agent import
+  abapgit-agent import --message "Initial import from SAP"
+`);
+      return;
+    }
+
+    // Get parameters from config
+    const config = loadConfig();
+    const repoUrl = gitUtils.getRemoteUrl();
+
+    if (!repoUrl) {
+      console.error('Error: No git remote configured. Please configure a remote origin.');
+      process.exit(1);
+    }
+
+    const messageArgIndex = args.indexOf('--message');
+    let commitMessage = null;
+    if (messageArgIndex !== -1 && messageArgIndex + 1 < args.length) {
+      commitMessage = args[messageArgIndex + 1];
+    }
+
+    console.log(`\n📦 Importing objects to git repository`);
+    console.log(`   URL: ${repoUrl}`);
+    if (commitMessage) {
+      console.log(`   Message: ${commitMessage}`);
+    }
+
+    const http = new AbapHttp(config);
+    const csrfToken = await http.fetchCsrfToken();
+
+    const data = {
+      url: repoUrl
+    };
+
+    if (commitMessage) {
+      data.message = commitMessage;
+    }
+
+    if (config.gitUsername) {
+      data.username = config.gitUsername;
+    }
+
+    if (config.gitPassword) {
+      data.password = config.gitPassword;
+    }
+
+    const result = await http.post('/sap/bc/z_abapgit_agent/import', data, { csrfToken });
+
+    console.log('\n');
+
+    // Handle uppercase keys from ABAP
+    const success = result.SUCCESS || result.success;
+    const filesStaged = result.FILES_STAGED || result.files_staged;
+    const abapCommitMessage = result.COMMIT_MESSAGE || result.commit_message;
+    const error = result.ERROR || result.error;
+
+    if (success === 'X' || success === true) {
+      console.log(`✅ Objects imported successfully!`);
+      console.log(`   Files staged: ${filesStaged}`);
+      console.log(`   Commit: ${commitMessage || abapCommitMessage}`);
+    } else {
+      console.log(`❌ Import failed`);
+      console.log(`   Error: ${error || 'Unknown error'}`);
+      process.exit(1);
+    }
+  }
+};

package/src/commands/init.js

@@ -0,0 +1,321 @@
+/**
+ * Init command - Initialize local repository configuration
+ */
+
+const pathModule = require('path');
+const fs = require('fs');
+
+/**
+ * Copy a file if source exists (helper for init --update)
+ */
+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)
+ */
+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}`);
+  }
+}
+
+module.exports = {
+  name: 'init',
+  description: 'Initialize local repository configuration',
+  requiresAbapConfig: false,
+  requiresVersionCheck: false,
+
+  async execute(args, context) {
+    const { gitUtils } = context;
+
+    const folderArgIndex = args.indexOf('--folder');
+    const packageArgIndex = args.indexOf('--package');
+    const updateMode = args.includes('--update');
+
+    // Get parameters
+    let folder = folderArgIndex !== -1 && folderArgIndex + 1 < args.length
+      ? args[folderArgIndex + 1]
+      : '/src/';
+
+    // Normalize folder path: ensure it starts with / and ends with /
+    folder = folder.trim();
+    if (!folder.startsWith('/')) {
+      folder = '/' + folder;
+    }
+    if (!folder.endsWith('/')) {
+      folder = folder + '/';
+    }
+
+    const packageName = packageArgIndex !== -1 && packageArgIndex + 1 < args.length
+      ? args[packageArgIndex + 1]
+      : null;
+
+    // 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);
+    }
+
+    // Check if current folder is git repo root
+    const gitDir = pathModule.join(process.cwd(), '.git');
+    if (!fs.existsSync(gitDir)) {
+      console.error('Error: Current folder is not a git repository.');
+      console.error('Run this command from the root folder of your git repository.');
+      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 = gitUtils.getRemoteUrl();
+    if (!gitUrl) {
+      console.error('Error: No git remote configured.');
+      console.error('Configure a remote with: git remote add origin <url>');
+      process.exit(1);
+    }
+    console.log(`📌 Git remote: ${gitUrl}`);
+
+    // Check if .abapGitAgent already exists
+    const configPath = pathModule.join(process.cwd(), '.abapGitAgent');
+    if (fs.existsSync(configPath)) {
+      console.error('Error: .abapGitAgent already exists.');
+      console.error('To reinitialize, delete the existing file first.');
+      process.exit(1);
+    }
+
+    // Copy .abapGitAgent.example to .abapGitAgent
+    const samplePath = pathModule.join(__dirname, '..', '..', '.abapGitAgent.example');
+    if (!fs.existsSync(samplePath)) {
+      console.error('Error: .abapGitAgent.example not found.');
+      process.exit(1);
+    }
+
+    try {
+      // Read sample and update with package/folder
+      const sampleContent = fs.readFileSync(samplePath, 'utf8');
+      const config = JSON.parse(sampleContent);
+      config.package = packageName;
+      config.folder = folder;
+
+      // Write updated config
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+      console.log(`✅ Created .abapGitAgent`);
+    } catch (error) {
+      console.error(`Error creating .abapGitAgent: ${error.message}`);
+      process.exit(1);
+    }
+
+    // Update .gitignore
+    const gitignorePath = pathModule.join(process.cwd(), '.gitignore');
+    const ignoreEntries = ['.abapGitAgent', '.abapgit_agent_cookies.txt'];
+    let existingIgnore = '';
+
+    if (fs.existsSync(gitignorePath)) {
+      existingIgnore = fs.readFileSync(gitignorePath, 'utf8');
+    }
+
+    let updated = false;
+    let newIgnoreContent = existingIgnore;
+
+    for (const entry of ignoreEntries) {
+      if (!newIgnoreContent.includes(entry)) {
+        if (newIgnoreContent && !newIgnoreContent.endsWith('\n')) {
+          newIgnoreContent += '\n';
+        }
+        newIgnoreContent += entry + '\n';
+        updated = true;
+      }
+    }
+
+    if (updated) {
+      fs.writeFileSync(gitignorePath, newIgnoreContent);
+      console.log(`✅ Updated .gitignore`);
+    } else {
+      fs.writeFileSync(gitignorePath, newIgnoreContent);
+      console.log(`✅ .gitignore already up to date`);
+    }
+
+    // Copy CLAUDE.md
+    const claudeMdPath = pathModule.join(__dirname, '..', '..', 'abap', 'CLAUDE.md');
+    const localClaudeMdPath = pathModule.join(process.cwd(), 'CLAUDE.md');
+    try {
+      if (fs.existsSync(claudeMdPath)) {
+        fs.copyFileSync(claudeMdPath, localClaudeMdPath);
+        console.log(`✅ Created CLAUDE.md`);
+      } else {
+        console.log(`⚠️  CLAUDE.md not found in abap/ directory`);
+      }
+    } catch (error) {
+      console.error(`Error copying CLAUDE.md: ${error.message}`);
+    }
+
+    // Copy copilot-instructions.md for GitHub Copilot
+    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 {
+      if (fs.existsSync(copilotMdPath)) {
+        // Ensure .github directory exists
+        if (!fs.existsSync(githubDir)) {
+          fs.mkdirSync(githubDir, { recursive: true });
+        }
+        fs.copyFileSync(copilotMdPath, localCopilotMdPath);
+        console.log(`✅ Created .github/copilot-instructions.md`);
+      } else {
+        console.log(`⚠️  copilot-instructions.md not found in abap/ directory`);
+      }
+    } catch (error) {
+      console.error(`Error copying copilot-instructions.md: ${error.message}`);
+    }
+
+    // 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 {
+      if (!fs.existsSync(folderPath)) {
+        fs.mkdirSync(folderPath, { recursive: true });
+        console.log(`✅ Created folder: ${folder}`);
+
+        // Create .gitkeep
+        const gitkeepPath = pathModule.join(folderPath, '.gitkeep');
+        fs.writeFileSync(gitkeepPath, '');
+      } else {
+        console.log(`✅ Folder already exists: ${folder}`);
+      }
+    } catch (error) {
+      console.error(`Error creating folder: ${error.message}`);
+    }
+
+    console.log(`
+📋 Next steps:
+   1. Edit .abapGitAgent with your ABAP credentials (host, user, password)
+   2. Run 'abapgit-agent create --import' to create online repository
+   3. Run 'abapgit-agent pull' to activate objects
+`);
+  }
+};

package/src/commands/inspect.js

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