abapgit-agent 1.13.1 → 1.13.2

package/README.md

@@ -115,7 +115,6 @@ npm run pull -- --url <git-url> --branch main
 | Installation & Setup | [INSTALL.md](INSTALL.md) |
 | All Commands Overview | [docs/commands.md](docs/commands.md) |
 | REST API Reference | [API.md](API.md) |
-| Error Handling | [ERROR_HANDLING.md](ERROR_HANDLING.md) |
 
 ## Dependent Projects
 

package/bin/abapgit-agent

@@ -34,32 +34,7 @@ async function main() {
   const args = process.argv.slice(2);
   const command = args[0];
 
-  // Load command modules (Phase 2 refactoring)
-  const commandModules = {
-    help: require('../src/commands/help'),
-    health: require('../src/commands/health'),
-    status: require('../src/commands/status'),
-    create: require('../src/commands/create'),
-    delete: require('../src/commands/delete'),
-    import: require('../src/commands/import'),
-    inspect: require('../src/commands/inspect'),
-    unit: require('../src/commands/unit'),
-    syntax: require('../src/commands/syntax'),
-    tree: require('../src/commands/tree'),
-    list: require('../src/commands/list'),
-    view: require('../src/commands/view'),
-    preview: require('../src/commands/preview'),
-    where: require('../src/commands/where'),
-    dump: require('../src/commands/dump'),
-    debug: require('../src/commands/debug'),
-    run: require('../src/commands/run'),
-    ref: require('../src/commands/ref'),
-    guide: require('../src/commands/guide'),
-    init: require('../src/commands/init'),
-    pull: require('../src/commands/pull'),
-    upgrade: require('../src/commands/upgrade'),
-    transport: require('../src/commands/transport')
-  };
+  const commandModules = require('../src/commands/index');
 
   // Check if this is a modular command
   if (commandModules[command] || command === '--help' || command === '-h') {

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "abapgit-agent",
-  "version": "1.13.1",
+  "version": "1.13.2",
   "description": "ABAP Git Agent - Pull and activate ABAP code via abapGit from any git repository",
-  "main": "src/index.js",
   "files": [
     "bin/",
     "src/",
@@ -18,8 +17,6 @@
     "abgagt": "bin/abgagt"
   },
   "scripts": {
-    "start": "node src/server.js",
-    "dev": "nodemon src/server.js",
     "test": "jest",
     "test:all": "node tests/run-all.js",
     "test:unit": "jest",
@@ -51,16 +48,13 @@
     "unrelease": "node scripts/unrelease.js"
   },
   "dependencies": {
-    "cors": "^2.8.5",
     "dotenv": "^16.3.1",
-    "express": "^4.18.2",
     "node-fetch": "^2.7.0",
     "uuid": "^9.0.0",
     "winston": "^3.11.0"
   },
   "devDependencies": {
     "jest": "^29.7.0",
-    "nodemon": "^3.0.1",
     "supertest": "^7.2.2"
   },
   "engines": {

package/src/commands/index.js

@@ -0,0 +1,33 @@
+'use strict';
+
+/**
+ * abapgit-agent command registry
+ *
+ * Each entry maps a CLI command name to its command module.
+ * Command modules must export: { name, description, requiresAbapConfig, execute }
+ */
+module.exports = {
+  help:      require('./help'),
+  health:    require('./health'),
+  status:    require('./status'),
+  create:    require('./create'),
+  delete:    require('./delete'),
+  import:    require('./import'),
+  inspect:   require('./inspect'),
+  unit:      require('./unit'),
+  syntax:    require('./syntax'),
+  tree:      require('./tree'),
+  list:      require('./list'),
+  view:      require('./view'),
+  preview:   require('./preview'),
+  where:     require('./where'),
+  dump:      require('./dump'),
+  debug:     require('./debug'),
+  run:       require('./run'),
+  ref:       require('./ref'),
+  guide:     require('./guide'),
+  init:      require('./init'),
+  pull:      require('./pull'),
+  upgrade:   require('./upgrade'),
+  transport: require('./transport')
+};

package/src/commands/pull.js

@@ -6,11 +6,38 @@ const { printHttpError } = require('../utils/format-error');
 const fs = require('fs');
 const pathModule = require('path');
 
+// Calculate display width accounting for emoji (2 cells) vs ASCII (1 cell)
+function calcWidth(str) {
+  if (!str) return 0;
+  let width = 0;
+  let i = 0;
+  while (i < str.length) {
+    const code = str.codePointAt(i);
+    if (!code) break;
+    // Variation selectors (FE00-FE0F) and ZWJ (200D) take 0 width
+    if (code >= 0xFE00 && code <= 0xFE0F) { i += 1; continue; }
+    if (code === 0x200D) { i += 1; continue; }  // Zero width joiner
+    // Emoji and wide characters take 2 cells
+    if (code > 0xFFFF) { width += 2; i += 2; }  // Skip surrogate pair
+    else if (code > 127) { width += 2; i += 1; }
+    else { width += 1; i += 1; }
+  }
+  return width;
+}
+
+// Pad string to display width
+function padToWidth(str, width) {
+  const s = str || '';
+  const currentWidth = calcWidth(s);
+  return s + ' '.repeat(Math.max(0, width - currentWidth));
+}
 module.exports = {
   name: 'pull',
   description: 'Pull and activate ABAP objects from git repository',
   requiresAbapConfig: true,
   requiresVersionCheck: true,
+  _calcWidth: calcWidth,
+  _padToWidth: padToWidth,
 
   async execute(args, context) {
     const { loadConfig, AbapHttp, gitUtils, getTransport, getSafeguards, getConflictSettings, getTransportSettings } = context;
@@ -281,44 +308,6 @@ module.exports = {
         return icons[type] || '';
       };
 
-      // Calculate display width accounting for emoji (2 cells) vs ASCII (1 cell)
-      const calcWidth = (str) => {
-        if (!str) return 0;
-        let width = 0;
-        let i = 0;
-        while (i < str.length) {
-          const code = str.codePointAt(i);
-          if (!code) break;
-          // Variation selectors (FE00-FE0F) and ZWJ (200D) take 0 width
-          if (code >= 0xFE00 && code <= 0xFE0F) {
-            i += 1;
-            continue;
-          }
-          if (code === 0x200D) {  // Zero width joiner
-            i += 1;
-            continue;
-          }
-          // Emoji and wide characters take 2 cells
-          if (code > 0xFFFF) {
-            width += 2;
-            i += 2;  // Skip surrogate pair
-          } else if (code > 127) {
-            width += 2;
-            i += 1;
-          } else {
-            width += 1;
-            i += 1;
-          }
-        }
-        return width;
-      };
-
-      // Pad string to display width
-      const padToWidth = (str, width) => {
-        const s = str || '';
-        const currentWidth = calcWidth(s);
-        return s + ' '.repeat(Math.max(0, width - currentWidth));
-      };
 
       if (success === 'X' || success === true) {
         console.log(`✅ Pull completed successfully!`);

package/src/commands/view.js

@@ -167,6 +167,8 @@ module.exports = {
   description: 'View ABAP object definitions from ABAP system',
   requiresAbapConfig: true,
   requiresVersionCheck: true,
+  _buildMethodLineMap: buildMethodLineMap,
+  _findFirstExecutableLine: findFirstExecutableLine,
 
   async execute(args, context) {
     const { loadConfig, AbapHttp } = context;

package/src/agent.js

@@ -1,512 +0,0 @@
-/**
- * ABAP Git Agent - Main agent class
- * Uses AbapHttp for all ABAP communication
- */
-
-const { AbapHttp } = require('./utils/abap-http');
-const { getAbapConfig } = require('./config');
-const logger = require('./logger');
-
-class ABAPGitAgent {
-  constructor() {
-    this.config = getAbapConfig();
-    this.http = new AbapHttp(this.config);
-  }
-
-  /**
-   * Pull repository and activate objects
-   * @param {string} repoUrl - Git repository URL
-   * @param {string} branch - Branch name (default: main)
-   * @param {string} username - Git username (optional)
-   * @param {string} password - Git password/token (optional)
-   * @param {Array} files - Specific files to pull (optional)
-   * @param {string} transportRequest - Transport request number (optional)
-   * @returns {object} Pull result with success, job_id, message, error_detail
-   */
-  async pull(repoUrl, branch = 'main', username = null, password = null, files = null, transportRequest = null) {
-    logger.info('Starting pull operation', { repoUrl, branch, username: !!username, files, transportRequest });
-
-    try {
-      const csrfToken = await this.http.fetchCsrfToken();
-
-      const data = {
-        url: repoUrl,
-        branch: branch,
-        username: username || this.config.gitUsername,
-        password: password || this.config.gitPassword
-      };
-
-      if (files && files.length > 0) {
-        data.files = files;
-      }
-
-      if (transportRequest) {
-        data.transport_request = transportRequest;
-      }
-
-      const result = await this.http.post('/sap/bc/z_abapgit_agent/pull', data, { csrfToken });
-
-      // Return the result directly from ABAP (handle uppercase keys from /UI2/CL_JSON)
-      return {
-        success: result.SUCCESS === 'X' || result.success === 'X' || result.success === true,
-        job_id: result.JOB_ID || result.job_id,
-        message: result.MESSAGE || result.message,
-        error_detail: result.ERROR_DETAIL || result.error_detail || null,
-        activated_count: result.ACTIVATED_COUNT || result.activated_count || 0,
-        failed_count: result.FAILED_COUNT || result.failed_count || 0,
-        activated_objects: result.ACTIVATED_OBJECTS || result.activated_objects || [],
-        failed_objects: result.FAILED_OBJECTS || result.failed_objects || []
-      };
-
-    } catch (error) {
-      logger.error('Pull failed', { error: error.message });
-      throw new Error(`Pull failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Health check
-   * @returns {object} Health status
-   */
-  async healthCheck() {
-    try {
-      const result = await this.http.get('/sap/bc/z_abapgit_agent/health');
-      return {
-        status: 'healthy',
-        abap: 'connected',
-        version: result.version || '1.4.0'
-      };
-    } catch (error) {
-      return {
-        status: 'unhealthy',
-        abap: 'disconnected',
-        error: error.message
-      };
-    }
-  }
-
-  /**
-   * Check syntax of an ABAP object (legacy - not used by CLI)
-   * @param {string} objectType - ABAP object type (e.g., 'CLAS', 'PROG', 'INTF')
-   * @param {string} objectName - ABAP object name
-   * @returns {object} Syntax check result with errors (if any)
-   */
-  async syntaxCheck(objectType, objectName) {
-    logger.info('Starting syntax check', { objectType, objectName });
-
-    try {
-      const csrfToken = await this.http.fetchCsrfToken();
-      const data = {
-        object_type: objectType,
-        object_name: objectName
-      };
-
-      const result = await this.http.post('/sap/bc/z_abapgit_agent/syntax-check', data, { csrfToken });
-      return {
-        success: result.SUCCESS === 'X' || result.success === 'X' || result.success === true,
-        object_type: result.OBJECT_TYPE || result.object_type,
-        object_name: result.OBJECT_NAME || result.object_name,
-        error_count: result.ERROR_COUNT || result.error_count || 0,
-        errors: result.ERRORS || result.errors || []
-      };
-    } catch (error) {
-      logger.error('Syntax check failed', { error: error.message });
-      throw new Error(`Syntax check failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Check syntax of ABAP source code directly (without pull/activation)
-   * Supported types: CLAS, INTF, PROG
-   * @param {Array} objects - Array of {type, name, source, locals_def?, locals_imp?}
-   * @param {string} uccheck - Unicode check mode ('X' for Standard, '5' for Cloud)
-   * @returns {object} Syntax check results with success, results array
-   */
-  async syntaxCheckSource(objects, uccheck = 'X') {
-    logger.info('Starting source syntax check', { objectCount: objects.length, uccheck });
-
-    try {
-      const csrfToken = await this.http.fetchCsrfToken();
-      const data = {
-        objects: objects,
-        uccheck: uccheck
-      };
-
-      const result = await this.http.post('/sap/bc/z_abapgit_agent/syntax', data, { csrfToken });
-      const success = result.SUCCESS === 'X' || result.SUCCESS === true ||
-                      result.success === 'X' || result.success === true;
-      const results = result.RESULTS || result.results || [];
-      const message = result.MESSAGE || result.message || '';
-
-      // Normalize results
-      const normalizedResults = results.map(r => ({
-        object_type: r.OBJECT_TYPE || r.object_type,
-        object_name: r.OBJECT_NAME || r.object_name,
-        success: r.SUCCESS === 'X' || r.SUCCESS === true || r.success === 'X' || r.success === true,
-        error_count: r.ERROR_COUNT || r.error_count || 0,
-        errors: r.ERRORS || r.errors || [],
-        warnings: r.WARNINGS || r.warnings || [],
-        message: r.MESSAGE || r.message || ''
-      }));
-
-      return {
-        success,
-        message,
-        results: normalizedResults
-      };
-    } catch (error) {
-      logger.error('Source syntax check failed', { error: error.message });
-      throw new Error(`Source syntax check failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Run unit tests for package or objects
-   * @param {string} packageName - Package name to run tests for (optional)
-   * @param {Array} objects - Array of {object_type, object_name} objects (optional)
-   * @returns {object} Unit test results with test_count, passed_count, failed_count, results
-   */
-  async unitCheck(packageName = null, objects = []) {
-    logger.info('Starting unit tests', { package: packageName, objects });
-
-    try {
-      const csrfToken = await this.http.fetchCsrfToken();
-      const data = {};
-
-      if (packageName) {
-        data.package = packageName;
-      }
-
-      if (objects && objects.length > 0) {
-        data.objects = objects;
-      }
-
-      const result = await this.http.post('/sap/bc/z_abapgit_agent/unit', data, { csrfToken });
-      return {
-        success: result.SUCCESS === 'X' || result.success === 'X' || result.success === true,
-        test_count: result.TEST_COUNT || result.test_count || 0,
-        passed_count: result.PASSED_COUNT || result.passed_count || 0,
-        failed_count: result.FAILED_COUNT || result.failed_count || 0,
-        message: result.MESSAGE || result.message || '',
-        errors: result.ERRORS || result.errors || []
-      };
-    } catch (error) {
-      logger.error('Unit tests failed', { error: error.message });
-      throw new Error(`Unit tests failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Create a new online repository
-   * @param {string} repoUrl - Git repository URL
-   * @param {string} packageName - ABAP package name
-   * @param {string} branch - Branch name (default: 'main')
-   * @param {string} displayName - Display name for the repository (optional)
-   * @param {string} name - Repository name (optional)
-   * @param {string} folderLogic - Folder logic: 'PREFIX' or 'FULL' (default: 'PREFIX')
-   * @returns {object} Create result with success, repo_key, repo_name, message
-   */
-  async create(repoUrl, packageName, branch = 'main', displayName = null, name = null, folderLogic = 'PREFIX') {
-    logger.info('Creating repository', { repoUrl, packageName, branch });
-
-    try {
-      const csrfToken = await this.http.fetchCsrfToken();
-      const data = {
-        url: repoUrl,
-        package: packageName,
-        branch: branch
-      };
-
-      if (displayName) {
-        data.display_name = displayName;
-      }
-
-      if (name) {
-        data.name = name;
-      }
-
-      if (folderLogic) {
-        data.folder_logic = folderLogic;
-      }
-
-      const result = await this.http.post('/sap/bc/z_abapgit_agent/create', data, { csrfToken });
-      return {
-        success: result.SUCCESS === 'X' || result.success === 'X' || result.success === true,
-        repo_key: result.REPO_KEY || result.repo_key,
-        repo_name: result.REPO_NAME || result.repo_name,
-        message: result.MESSAGE || result.message || '',
-        error: result.ERROR || result.error || null
-      };
-    } catch (error) {
-      logger.error('Create failed', { error: error.message });
-      throw new Error(`Create failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Import existing objects from package to git repository
-   * @param {string} repoUrl - Git repository URL
-   * @param {string} message - Commit message (optional)
-   * @returns {object} Import result with success, files_staged, commit_sha
-   */
-  async import(repoUrl, message = null) {
-    logger.info('Starting import operation', { repoUrl, message });
-
-    try {
-      const csrfToken = await this.http.fetchCsrfToken();
-      const data = {
-        url: repoUrl
-      };
-
-      if (message) {
-        data.message = message;
-      }
-
-      const result = await this.http.post('/sap/bc/z_abapgit_agent/import', data, { csrfToken });
-      return {
-        success: result.SUCCESS === 'X' || result.success === 'X' || result.success === true,
-        files_staged: result.FILES_STAGED || result.files_staged || 0,
-        commit_sha: result.COMMIT_SHA || result.commit_sha || '',
-        message: result.MESSAGE || result.message || '',
-        error: result.ERROR || result.error || null
-      };
-    } catch (error) {
-      logger.error('Import failed', { error: error.message });
-      throw new Error(`Import failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Get package hierarchy tree
-   * @param {string} packageName - ABAP package name
-   * @param {number} depth - Maximum depth to traverse (default: 3)
-   * @param {boolean} includeObjects - Include object counts breakdown
-   * @returns {object} Tree result with hierarchy, summary, and metadata
-   */
-  async tree(packageName, depth = 3, includeObjects = false) {
-    logger.info('Getting package tree', { package: packageName, depth, includeObjects });
-
-    try {
-      const csrfToken = await this.http.fetchCsrfToken();
-      const data = {
-        package: packageName,
-        depth: Math.min(Math.max(1, depth), 10),
-        include_objects: includeObjects
-      };
-
-      const result = await this.http.post('/sap/bc/z_abapgit_agent/tree', data, { csrfToken });
-      return {
-        success: result.SUCCESS === 'X' || result.success === 'X' || result.success === true,
-        command: result.COMMAND || result.command || 'TREE',
-        package: result.PACKAGE || result.package,
-        message: result.MESSAGE || result.message || '',
-        hierarchy: result.HIERARCHY || result.hierarchy || null,
-        summary: result.SUMMARY || result.summary || null,
-        error: result.ERROR || result.error || null
-      };
-    } catch (error) {
-      logger.error('Tree command failed', { error: error.message });
-      throw new Error(`Tree command failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Preview data from ABAP tables or CDS views
-   * @param {Array} objects - Array of table/view names
-   * @param {string} type - Object type (TABL, DDLS, etc.)
-   * @param {number} limit - Maximum rows to return
-   * @param {number} offset - Number of rows to skip
-   * @param {string} where - WHERE clause filter
-   * @param {Array} columns - Array of column names to display
-   * @returns {object} Preview result with rows, fields, and metadata
-   */
-  async preview(objects, type = null, limit = 100, offset = 0, where = null, columns = null) {
-    logger.info('Previewing data', { objects, type, limit, offset, where, columns });
-
-    try {
-      const csrfToken = await this.http.fetchCsrfToken();
-      const data = {
-        objects: objects,
-        limit: Math.min(Math.max(1, limit), 500),
-        offset: Math.max(0, offset)
-      };
-
-      if (type) {
-        data.type = type;
-      }
-
-      if (where) {
-        // Convert ISO date format (YYYY-MM-DD) to ABAP DATS format (YYYYMMDD)
-        data.where = this.convertDatesInWhereClause(where);
-      }
-
-      if (columns) {
-        data.columns = columns;
-      }
-
-      const result = await this.http.post('/sap/bc/z_abapgit_agent/preview', data, { csrfToken });
-      return {
-        success: result.SUCCESS === 'X' || result.success === 'X' || result.success === true,
-        command: result.COMMAND || result.command || 'PREVIEW',
-        message: result.MESSAGE || result.message || '',
-        objects: result.OBJECTS || result.objects || [],
-        summary: result.SUMMARY || result.summary || null,
-        pagination: result.PAGINATION || result.pagination || null,
-        error: result.ERROR || result.error || null
-      };
-    } catch (error) {
-      logger.error('Preview command failed', { error: error.message });
-      throw new Error(`Preview command failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Convert ISO date formats to ABAP DATS format in WHERE clause
-   * @param {string} whereClause - SQL WHERE clause
-   * @returns {string} - WHERE clause with dates converted to YYYYMMDD format
-   */
-  convertDatesInWhereClause(whereClause) {
-    if (!whereClause) return whereClause;
-
-    const isoDatePattern = /'\\d{4}-\\d{2}-\\d{2}'/g;
-    return whereClause.replace(isoDatePattern, (match) => {
-      const dateContent = match.slice(1, -1);
-      const [year, month, day] = dateContent.split('-');
-      return `'${year}${month}${day}'`;
-    });
-  }
-
-  /**
-   * List objects in an ABAP package
-   * @param {string} packageName - ABAP package name
-   * @param {string} type - Comma-separated object types to filter (optional)
-   * @param {string} name - Name pattern to filter (optional)
-   * @param {number} limit - Maximum number of objects to return (default: 100)
-   * @param {number} offset - Offset for pagination (default: 0)
-   * @returns {object} List result with objects, by_type, total, and error
-   */
-  async list(packageName, type = null, name = null, limit = 100, offset = 0) {
-    logger.info('Listing objects', { package: packageName, type, name, limit, offset });
-
-    try {
-      const csrfToken = await this.http.fetchCsrfToken();
-      const data = {
-        package: packageName,
-        limit: Math.min(Math.max(1, limit), 1000),
-        offset: Math.max(0, offset)
-      };
-
-      if (type) {
-        data.type = type;
-      }
-
-      if (name) {
-        data.name = name;
-      }
-
-      const result = await this.http.post('/sap/bc/z_abapgit_agent/list', data, { csrfToken });
-
-      // Normalize objects array to use lowercase keys
-      const rawObjects = result.OBJECTS || result.objects || [];
-      const normalizedObjects = rawObjects.map(obj => ({
-        type: obj.TYPE || obj.type,
-        name: obj.NAME || obj.name
-      }));
-
-      // Normalize by_type array to use lowercase keys
-      const rawByType = result.BY_TYPE || result.by_type || [];
-      const normalizedByType = rawByType.map(item => ({
-        type: item.TYPE || item.type,
-        count: item.COUNT || item.count || 0
-      }));
-
-      return {
-        success: result.SUCCESS === 'X' || result.success === 'X' || result.success === true,
-        command: result.COMMAND || result.command || 'LIST',
-        package: result.PACKAGE || result.package || packageName,
-        message: result.MESSAGE || result.message || '',
-        objects: normalizedObjects,
-        by_type: normalizedByType,
-        total: result.TOTAL || result.total || 0,
-        error: result.ERROR || result.error || null
-      };
-    } catch (error) {
-      logger.error('List command failed', { error: error.message });
-      throw new Error(`List command failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * View ABAP object definitions
-   * @param {Array} objects - Array of object names to view
-   * @param {string} type - Object type (optional, e.g., 'CLAS', 'TABL')
-   * @returns {object} View result with object definitions
-   */
-  async view(objects, type = null) {
-    logger.info('Viewing objects', { objects, type });
-
-    try {
-      const csrfToken = await this.http.fetchCsrfToken();
-      const data = {
-        objects: objects
-      };
-
-      if (type) {
-        data.type = type;
-      }
-
-      const result = await this.http.post('/sap/bc/z_abapgit_agent/view', data, { csrfToken });
-      return {
-        success: result.SUCCESS === 'X' || result.success === 'X' || result.success === true,
-        command: result.COMMAND || result.command || 'VIEW',
-        objects: result.OBJECTS || result.objects || [],
-        error: result.ERROR || result.error || null
-      };
-    } catch (error) {
-      logger.error('View command failed', { error: error.message });
-      throw new Error(`View command failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Find where-used list for ABAP objects
-   * @param {Array} objects - Array of object names to search
-   * @param {string} type - Object type (optional)
-   * @param {number} limit - Maximum results (default: 100, max: 500)
-   * @param {number} offset - Number of results to skip (default: 0)
-   * @returns {object} Where-used result with found objects
-   */
-  async where(objects, type = null, limit = 100, offset = 0) {
-    logger.info('Finding where-used', { objects, type, limit, offset });
-
-    try {
-      const csrfToken = await this.http.fetchCsrfToken();
-      const data = {
-        objects: objects,
-        limit: Math.min(Math.max(1, limit), 500),
-        offset: Math.max(0, offset)
-      };
-
-      if (type) {
-        data.type = type;
-      }
-
-      const result = await this.http.post('/sap/bc/z_abapgit_agent/where-used', data, { csrfToken });
-      return {
-        success: result.SUCCESS === 'X' || result.success === 'X' || result.success === true,
-        command: result.COMMAND || result.command || 'WHERE',
-        objects: result.OBJECTS || result.objects || [],
-        message: result.MESSAGE || result.message || '',
-        pagination: result.PAGINATION || result.pagination || null,
-        error: result.ERROR || result.error || null
-      };
-    } catch (error) {
-      logger.error('Where command failed', { error: error.message });
-      throw new Error(`Where command failed: ${error.message}`);
-    }
-  }
-}
-
-module.exports = {
-  ABAPGitAgent
-};

package/src/index.js

@@ -1,48 +0,0 @@
-/**
- * ABAP Git Agent - Package Entry Point
- *
- * Exports functions for programmatic use:
- *   const { pull, healthCheck } = require('abapgit-agent');
- */
-
-const { ABAPGitAgent } = require('./agent');
-
-/**
- * Pull repository and activate objects
- * @param {string} repoUrl - Git repository URL
- * @param {string} branch - Branch name (default: main)
- * @param {string} username - Git username (optional)
- * @param {string} password - Git password/token (optional)
- * @returns {object} Pull result with success, job_id, message, error_detail
- */
-async function pull(repoUrl, branch = 'main', username = null, password = null) {
-  const agent = new ABAPGitAgent();
-  return await agent.pull(repoUrl, branch, username, password);
-}
-
-/**
- * Check agent health
- * @returns {object} Health status
- */
-async function healthCheck() {
-  const agent = new ABAPGitAgent();
-  return await agent.healthCheck();
-}
-
-/**
- * Check if integration is configured for current directory
- * @returns {boolean} True if .abapGitAgent exists
- */
-function isConfigured() {
-  const fs = require('fs');
-  const path = require('path');
-  const repoConfigPath = path.join(process.cwd(), '.abapGitAgent');
-  return fs.existsSync(repoConfigPath);
-}
-
-module.exports = {
-  pull,
-  healthCheck,
-  isConfigured,
-  ABAPGitAgent
-};

package/src/server.js

@@ -1,116 +0,0 @@
-/**
- * HTTP Server for Claude Integration
- */
-
-const express = require('express');
-const cors = require('cors');
-const { ABAPGitAgent } = require('./agent');
-const { getAgentConfig } = require('./config');
-const logger = require('./logger');
-
-class Server {
-  constructor() {
-    this.app = express();
-    this.agent = new ABAPGitAgent();
-    this.agentConfig = getAgentConfig();
-
-    this.setupMiddleware();
-    this.setupRoutes();
-  }
-
-  setupMiddleware() {
-    this.app.use(cors());
-    this.app.use(express.json());
-
-    // Request logging
-    this.app.use((req, res, next) => {
-      logger.debug(`${req.method} ${req.path}`, { body: req.body });
-      next();
-    });
-
-    // Error handling
-    this.app.use((err, req, res, next) => {
-      logger.error('Request error', { error: err.message, stack: err.stack });
-      res.status(500).json({
-        success: false,
-        error: err.message
-      });
-    });
-  }
-
-  setupRoutes() {
-    // Health check
-    this.app.get('/api/health', async (req, res) => {
-      try {
-        const health = await this.agent.healthCheck();
-        res.json(health);
-      } catch (error) {
-        res.status(503).json({
-          status: 'unhealthy',
-          error: error.message
-        });
-      }
-    });
-
-    // Pull repository (synchronous - returns immediately with result)
-    this.app.post('/api/pull', async (req, res) => {
-      try {
-        const { url, branch, username, password } = req.body;
-
-        if (!url) {
-          return res.status(400).json({
-            success: false,
-            error: 'Missing required parameter: url'
-          });
-        }
-
-        const result = await this.agent.pull(url, branch, username, password);
-        res.json(result);
-
-      } catch (error) {
-        logger.error('Pull failed', { error: error.message });
-        res.status(500).json({
-          success: false,
-          error: error.message
-        });
-      }
-    });
-  }
-
-  start() {
-    const port = this.agentConfig.port || 3000;
-
-    this.server = this.app.listen(port, () => {
-      logger.info(`ABAP AI Bridge server started on port ${port}`);
-      console.log(`\n🚀 ABAP AI Bridge is running!`);
-      console.log(`   Health:   http://localhost:${port}/api/health`);
-      console.log(`   Pull:     POST http://localhost:${port}/api/pull`);
-      console.log(`\n📚 API Documentation:`);
-      console.log(`   POST /api/pull { "url": "git-url", "branch": "main" }`);
-    });
-
-    // Graceful shutdown
-    process.on('SIGTERM', () => this.shutdown());
-    process.on('SIGINT', () => this.shutdown());
-  }
-
-  shutdown() {
-    logger.info('Shutting down server...');
-    if (this.server) {
-      this.server.close(() => {
-        logger.info('Server closed');
-        process.exit(0);
-      });
-    }
-  }
-}
-
-// Start server if run directly
-if (require.main === module) {
-  const server = new Server();
-  server.start();
-}
-
-module.exports = {
-  Server
-};