abapgit-agent 1.7.1 → 1.8.0

package/src/commands/help.js

@@ -0,0 +1,111 @@
+/**
+ * Help command - Display usage information
+ */
+
+module.exports = {
+  name: 'help',
+  description: 'Display usage information and available commands',
+  requiresAbapConfig: false,
+  requiresVersionCheck: false,
+
+  async execute(args, context) {
+    console.log(`
+ABAP Git Agent
+
+Usage:
+  abapgit-agent <command> [options]
+
+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.
+    Auto-detects URL from git remote and package from .abapGitAgent.
+
+  import [--message <message>]
+    Import existing objects from package to git repository.
+    Uses the git remote URL to find the abapGit online repository.
+
+  pull [--url <git-url>] [--branch <branch>] [--files <file1,file2,...>] [--transport <request>]
+    Pull and activate repository in ABAP system.
+    Auto-detects git remote and branch from current directory.
+    Use --files to pull only specific files.
+    Use --transport to specify a transport request.
+
+  inspect --files <file1>,<file2>,...
+    Inspect ABAP source file(s) for issues. Currently runs syntax check.
+
+  syntax --files <file1>,<file2>,... [--cloud] [--json]
+    Check syntax of ABAP source files WITHOUT pull/activation.
+    Reads source from local files and checks directly in ABAP system.
+    Use --cloud for ABAP Cloud (BTP) stricter syntax checking.
+
+  unit --files <file1>,<file2>,...
+    Run AUnit tests for ABAP test class files (.testclasses.abap)
+
+  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
+
+  where --objects <obj1>,<obj2>,... [--type <type>] [--limit <n>] [--json]
+    Find where-used list for ABAP objects (classes, interfaces, programs)
+
+  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 --clone <repo> [--name <folder>]
+    Clone a GitHub repository to the reference folder
+    - Use full URL: https://github.com/user/repo.git
+    - Or short name: user/repo or user/repo (assumes github.com)
+
+  health
+    Check if ABAP REST API is healthy
+
+  status
+    Check if ABAP integration is configured for this repo
+
+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 delete                                       # Delete repo
+  abapgit-agent import                                       # Import objects to git
+  abapgit-agent import --message "Initial import"            # Import with message
+  abapgit-agent pull                                         # Auto-detect from git
+  abapgit-agent pull --branch develop                        # Specific branch
+  abapgit-agent pull --files src/zcl_my_class.clas.abap          # Specific file
+  abapgit-agent pull --transport DEVK900001                  # With transport
+  abapgit-agent inspect --files src/zcl_my_class.clas.abap       # Syntax check
+  abapgit-agent syntax --files src/zcl_my_class.clas.abap        # Check without pull
+  abapgit-agent syntax --files src/zmy_prog.prog.abap --cloud    # ABAP Cloud check
+  abapgit-agent unit --files src/zcl_my_test.clas.testclasses.abap  # Run unit tests
+  abapgit-agent tree --package $MY_PACKAGE                   # Display package tree
+  abapgit-agent list --package $MY_PACKAGE --type CLAS,INTF  # List classes & interfaces
+  abapgit-agent view --objects ZCL_MY_CLASS                  # View class definition
+  abapgit-agent where --objects ZCL_MY_CLASS                 # Find where class is used
+  abapgit-agent ref "CORRESPONDING"                          # Search for pattern
+  abapgit-agent ref --topic exceptions                       # View exceptions topic
+  abapgit-agent health                                       # Health check
+  abapgit-agent status                                       # Configuration status
+
+For more info: https://github.tools.sap/I045696/abapgit-agent
+`);
+  }
+};

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
+`);
+  }
+};