abapgit-agent 1.6.0 → 1.6.1

package/abap/guidelines/00_index.md

@@ -14,6 +14,7 @@ This folder contains detailed ABAP coding guidelines that can be searched using
 | `06_objects.md` | Object Naming Conventions |
 | `07_json.md` | JSON Handling |
 | `08_abapgit.md` | abapGit XML Metadata Templates |
+| `09_unit_testable_code.md` | Unit Testable Code Guidelines (Dependency Injection) |
 
 ## Usage
 

package/abap/guidelines/01_sql.md

@@ -1,7 +1,16 @@
 # ABAP SQL Best Practices
 
+**Searchable keywords**: SELECT, FROM, WHERE, ABAP SQL, Open SQL, host variable, @ prefix, range table, INTO, UP TO, OFFSET, GROUP BY, JOIN
+
 When writing ABAP SQL (Open SQL) queries, follow these rules:
 
+## TOPICS IN THIS FILE
+1. Host Variables (@ prefix) - line 5
+2. Range Tables (IN clause) - line 17
+3. SELECT Clause Order - line 35
+4. Fixed Point Arithmetic - line 52
+5. Field Separation - line 62
+
 ## 1. Host Variables - Use @ Prefix
 
 Use `@` prefix for host variables in ABAP SQL:
@@ -70,3 +79,10 @@ SELECT object, obj_name FROM tadir ...
 " Wrong - missing comma
 SELECT object obj_name FROM tadir ...
 ```
+
+---
+
+## See Also
+- **Constructor Expressions** (05_classes.md) - for VALUE #(), FILTER, FOR loops
+- **Internal Tables** - for filtering and iteration patterns
+- **abapGit** (08_abapgit.md) - for XML metadata templates

package/abap/guidelines/02_exceptions.md

@@ -1,5 +1,15 @@
 # Exception Handling - Classical vs Class-Based
 
+**Searchable keywords**: exception, RAISING, TRY, CATCH, cx_static_check, cx_dynamic_check, EXCEPTIONS, sy-subrc, class-based exception, classical exception
+
+## TOPICS IN THIS FILE
+1. Quick Identification - line 5
+2. Classical Exceptions - line 12
+3. Class-Based Exceptions - line 25
+4. Method Signatures - line 50
+5. Best Practices - line 80
+6. Interface vs Class Methods - line 118
+
 ABAP has two exception handling mechanisms. Using the wrong one causes silent failures.
 
 ## Quick Identification
@@ -106,3 +116,61 @@ Or search the cheat sheets:
 ```bash
 abapgit-agent ref --topic exceptions
 ```
+
+## Interface vs Class Methods
+
+### Interface Methods
+
+Cannot add RAISING clause in the implementing class. Options:
+
+1. Add RAISING to interface definition
+2. Use TRY-CATCH in the implementation
+
+```abap
+" Interface definition - can add RAISING here
+INTERFACE zif_example.
+  methods execute
+    importing is_param type data optional
+    returning value(rv_result) type string
+    raising cx_static_check.
+ENDINTERFACE.
+
+" Implementation - CANNOT add RAISING here
+CLASS zcl_example DEFINITION.
+  INTERFACES zif_example.
+ENDCLASS.
+
+CLASS zcl_example IMPLEMENTATION.
+  METHOD zif_example~execute.
+    " Must handle cx_static_check here with TRY-CATCH
+    " or declare it in interface, not here
+  ENDMETHOD.
+ENDCLASS.
+```
+
+### Class Methods
+
+Can add RAISING clause to declare exceptions, allowing caller to handle in one place:
+
+```abap
+" Class method with RAISING clause
+METHODS process_data
+  importing iv_data type string
+  returning value(rv_result) type string
+  raising cx_static_check.
+
+" Caller can handle in one place
+TRY.
+    lv_result = lo_obj->process_data( iv_data = 'test' ).
+  CATCH cx_static_check.
+    " Handle exception
+ENDTRY.
+```
+
+### When to Use Each
+
+| Scenario | Recommendation |
+|----------|----------------|
+| Multiple callers need to handle exception | Add RAISING to method definition |
+| Exception should be handled internally | Use TRY-CATCH in implementation |
+| Interface method | Add RAISING to interface, or use TRY-CATCH in class |

package/abap/guidelines/03_testing.md

@@ -1,5 +1,15 @@
 # Unit Testing
 
+**Searchable keywords**: unit test, AUnit, test class, cl_abap_unit_assert, FOR TESTING, setup, teardown, RISK LEVEL, DURATION, CDS test double, CL_CDS_TEST_ENVIRONMENT
+
+## TOPICS IN THIS FILE
+1. Local Test Classes - line 3
+2. File Structure - line 5
+3. Required Elements - line 16
+4. Naming Conventions - line 48
+5. CDS Test Doubles - line 94
+6. CDS with Aggregations - line 178
+
 ## Unit Testing with Local Test Classes
 
 ### File Structure
@@ -250,3 +260,10 @@ ENDMETHOD.
 abapgit-agent ref "cl_cds_test_environment"
 abapgit-agent ref --topic unit-tests
 ```
+
+---
+
+## See Also
+- **CDS Views** (04_cds.md) - for CDS view definitions and syntax
+- **abapGit** (08_abapgit.md) - for WITH_UNIT_TESTS in XML metadata
+- **ABAP SQL** (01_sql.md) - for SELECT statements in tests

package/abap/guidelines/04_cds.md

@@ -1,5 +1,14 @@
 # Creating CDS Views
 
+**Searchable keywords**: CDS, DDL, DDLS, CDS view, @AbapCatalog, @AccessControl, association, projection, consumption
+
+## TOPICS IN THIS FILE
+1. File Naming - line 7
+2. DDL Source (.ddls.asddls) - line 18
+3. Annotations - line 50
+4. Associations - line 75
+5. CDS Test Doubles - see 03_testing.md
+
 ## Creating CDS Views (DDLS)
 
 CDS views (Data Definition Language Source) require specific file naming and structure for abapGit.
@@ -118,3 +127,10 @@ When working with CDS view syntax (arithmetic, built-in functions, aggregations,
    - `zdemo_abap_cds_ve_assoc.ddls.asddls` - Associations
 
 **Note**: This requires `abap-cheat-sheets` to be in the reference folder (configured in `.abapGitAgent`).
+
+---
+
+## See Also
+- **Unit Testing** (03_testing.md) - for CDS Test Double Framework
+- **abapGit** (08_abapgit.md) - for CDS XML metadata templates
+- **ABAP SQL** (01_sql.md) - for SQL functions used in CDS

package/abap/guidelines/05_classes.md

@@ -1,5 +1,13 @@
 # ABAP Classes and Objects
 
+**Searchable keywords**: CLASS, DEFINITION, PUBLIC, CREATE OBJECT, NEW, METHOD, INTERFACES, inheritance, FINAL, ABSTRACT
+
+## TOPICS IN THIS FILE
+1. Class Definition (PUBLIC) - line 3
+2. Constructor - line 20
+3. Interfaces - line 35
+4. Inline Declaration - line 50
+
 ## ABAP Class Definition - Must Use PUBLIC
 
 **CRITICAL**: Global ABAP classes MUST use `PUBLIC` in the class definition:

package/abap/guidelines/06_objects.md

@@ -1,5 +1,12 @@
 # ABAP Objects
 
+**Searchable keywords**: naming convention, Z prefix, namespace, object type, CLAS, INTF, PROG, TABL, DDLS, XML metadata, .abapGit.xml
+
+## TOPICS IN THIS FILE
+1. XML Metadata Required - line 3
+2. Naming Conventions - line 30
+3. Object Types - line 60
+
 ## Creating New ABAP Objects - XML Metadata Required
 
 **CRITICAL CHECKLIST - Never Forget!**

package/abap/guidelines/07_json.md

@@ -1,5 +1,7 @@
 # JSON Handling
 
+**Searchable keywords**: JSON, serialize, deserialize, /ui2/cl_json, REST API, API response
+
 **CRITICAL**: Always use `/ui2/cl_json` for JSON serialization and deserialization.
 
 ## Correct Usage

package/abap/guidelines/08_abapgit.md

@@ -2,6 +2,35 @@
 
 Each ABAP object requires an XML metadata file for abapGit to understand how to serialize/deserialize it. This guide provides templates for common object types.
 
+## QUICK REFERENCE
+
+```
+File Type          | ABAP File                    | XML File
+-------------------|------------------------------|-------------------
+Class              | zcl_*.clas.abap              | zcl_*.clas.xml
+Test Class         | zcl_*.clas.testclasses.abap | zcl_*.clas.xml
+Interface          | zif_*.intf.abap             | zif_*.intf.xml
+Program            | z*.prog.abap                | z*.prog.xml
+Table              | z*.tabl.abap                | z*.tabl.xml
+CDS View           | zc_*.ddls.asddls            | zc_*.ddls.xml
+CDS Entity         | ze_*.ddlx.asddlx            | ze_*.ddlx.xml
+Data Element       | z*.dtel.abap                | z*.dtel.xml
+Structure          | z*.stru.abap                | z*.stru.xml
+Table Type         | z*.ttyp.abap                | z*.ttyp.xml
+```
+
+```
+Key XML Settings:
+  Class EXPOSURE:   2=Public, 3=Protected, 4=Private
+  Class STATE:      1=Active
+  Table TABCLASS:   TRANSP, POOL, CLUSTER
+  Table DELIVERY:   A=Application, C=Customizing
+  CDS SOURCE_TYPE:  V=View, C=Consumption
+  Test Class XML:   <WITH_UNIT_TESTS>X</WITH_UNIT_TESTS>
+```
+
+**Searchable keywords**: class xml, interface xml, table xml, cds xml, test class, exposure, serializer, abapgit
+
 ## Why XML Metadata?
 
 abapGit needs XML files to:

package/abap/guidelines/09_unit_testable_code.md

@@ -0,0 +1,568 @@
+# ABAP Unit Testable Code Guidelines
+
+This document provides guidelines for creating ABAP OO classes/interfaces that can be easily unit tested with test doubles. These guidelines help AI coding tools understand how to design classes that are testable without requiring real dependencies.
+
+## The Problem
+
+When ABAP classes are not designed for testability, unit tests cannot mock dependencies. This leads to:
+
+- Tests that depend on real external systems (databases, APIs, file systems)
+- Tests that fail in different environments
+- Tests that are slow and unreliable
+- Impossible to test error conditions
+
+**Example of untestable code:**
+
+```abap
+" BAD - Hardcoded dependency, cannot be replaced in tests
+CLASS zcl_abgagt_command_pull DEFINITION PUBLIC.
+  METHOD execute.
+    lo_agent = NEW zcl_abgagt_agent( ).  " Hardcoded!
+    ls_result = lo_agent->pull( ... ).   " Calls real system
+  ENDMETHOD.
+ENDCLASS.
+```
+
+The unit test will instantiate the REAL `zcl_abgagt_agent` which tries to connect to abapGit and a real git repository, causing test failures.
+
+---
+
+## Core Principles
+
+### 1. Dependency Inversion (Dependency Injection)
+
+**Pass dependencies through constructor instead of creating them internally.**
+
+```abap
+" GOOD - Dependency injected via constructor
+CLASS zcl_abgagt_command_pull DEFINITION PUBLIC.
+  PUBLIC SECTION.
+    INTERFACES zif_abgagt_command.
+
+    " Constructor injection
+    METHODS constructor
+      IMPORTING
+        io_agent TYPE REF TO zif_abgagt_agent.
+
+  PRIVATE SECTION.
+    DATA mo_agent TYPE REF TO zif_abgagt_agent.
+
+ENDCLASS.
+
+CLASS zcl_abgagt_command_pull IMPLEMENTATION.
+
+  METHOD constructor.
+    super->constructor( ).
+    mo_agent = io_agent.
+  ENDMETHOD.
+
+  METHOD execute.
+    " Use injected dependency
+    ls_result = mo_agent->pull( ... ).
+  ENDMETHOD.
+
+ENDCLASS.
+```
+
+**In production code:**
+```abap
+DATA(lo_command) = NEW zcl_abgagt_command_pull(
+  io_agent = NEW zcl_abgagt_agent( ) ).
+```
+
+**In test code:**
+```abap
+" Create test double
+CLASS ltd_mock_agent DEFINITION FOR TESTING.
+  PUBLIC SECTION.
+    INTERFACES zif_abgagt_agent PARTIALLY IMPLEMENTED.
+ENDCLASS.
+
+CLASS ltd_mock_agent IMPLEMENTATION.
+  METHOD zif_abgagt_agent~pull.
+    " Return test data instead of calling real system
+    rs_result-success = abap_true.
+    rs_result-message = 'Test success'.
+  ENDMETHOD.
+ENDCLASS.
+
+" Test uses test double
+CLASS ltcl_test DEFINITION FOR TESTING.
+  METHOD test_execute.
+    DATA(lo_mock) = NEW ltd_mock_agent( ).
+    DATA(lo_cut) = NEW zcl_abgagt_command_pull( io_agent = lo_mock ).
+
+    DATA(lv_result) = lo_cut->execute( ... ).
+
+    " Assert expected results
+  ENDMETHOD.
+ENDCLASS.
+```
+
+### 2. Always Use Interfaces for Dependencies
+
+**Never depend on concrete classes - depend on interfaces.**
+
+```abap
+" GOOD - Depend on interface
+DATA mo_agent TYPE REF TO zif_abgagt_agent.  " Interface!
+
+" BAD - Depends on concrete class
+DATA mo_agent TYPE REF TO zcl_abgagt_agent.   " Concrete class!
+```
+
+This allows you to replace the implementation with test doubles.
+
+### 3. Make Dependencies Injectable via Constructor
+
+**Use constructor injection, not setter injection.**
+
+```abap
+" GOOD - Constructor injection (required dependency)
+METHODS constructor
+  IMPORTING
+    io_agent TYPE REF TO zif_abgagt_agent.
+
+" BAD - Setter injection (optional, can be forgotten)
+METHODS set_agent
+  IMPORTING
+    io_agent TYPE REF TO zif_abgagt_agent.
+```
+
+Constructor injection:
+- Makes dependency explicit
+- Ensures object is always in valid state
+- Cannot forget to inject
+
+### 4. Avoid Static Calls
+
+**Static method calls cannot be mocked/test-doubled.**
+
+```abap
+" BAD - Static call cannot be replaced
+DATA(li_repo) = zcl_abapgit_repo_srv=>get_instance( )->get_repo_from_url( ... ).
+
+" GOOD - Instance method via injected dependency
+DATA(li_repo) = mo_repo_srv->get_repo_from_url( ... ).
+```
+
+If you must call static methods, wrap them in an instance method of an injected class.
+
+### 5. Keep Constructor Simple
+
+**Constructor should only assign dependencies, not perform complex logic.**
+
+```abap
+" GOOD - Simple constructor
+METHOD constructor.
+  mo_agent = io_agent.
+  mo_logger = io_logger.
+ENDMETHOD.
+
+" BAD - Complex logic in constructor
+METHOD constructor.
+  mo_agent = io_agent.
+  " Don't do this here:
+  mo_agent->connect( ).  " Network call in constructor!
+  DATA(ls_config) = read_config( ).  " File I/O in constructor!
+ENDMETHOD.
+```
+
+---
+
+## Injection Techniques
+
+### Constructor Injection (Recommended)
+
+```abap
+CLASS zcl_my_class DEFINITION PUBLIC.
+  PUBLIC SECTION.
+    METHODS constructor
+      IMPORTING
+        io_dependency TYPE REF TO zif_my_interface.
+  PRIVATE SECTION.
+    DATA mo_dependency TYPE REF TO zif_my_interface.
+ENDCLASS.
+```
+
+### Back Door Injection (for existing code)
+
+When you cannot modify the constructor, use friendship:
+
+```abap
+" In test class
+CLASS zcl_my_class DEFINITION LOCAL FRIENDS ltcl_test.
+
+CLASS ltcl_test IMPLEMENTATION.
+  METHOD test_with_mock.
+    " Directly set private attribute via friendship
+    CREATE OBJECT mo_cut.
+    mo_cut->mo_dependency = lo_mock.  " Access private attribute
+  ENDMETHOD.
+ENDCLASS.
+```
+
+### Test Seams (last resort)
+
+For legacy code that cannot be refactored:
+
+```abap
+" In production code
+METHOD get_data.
+  TEST-SEAM db_select.
+    SELECT * FROM dbtab INTO TABLE @DATA(lt_data).
+  END-TEST-SEAM.
+ENDMETHOD.
+
+" In test class
+METHOD test_get_data.
+  TEST-INJECTION db_select.
+    lt_data = VALUE #( ( id = '1' ) ( id = '2' ) ).
+  END-TEST-INJECTION.
+
+  DATA(lt_result) = mo_cut->get_data( ).
+ENDMETHOD.
+```
+
+---
+
+## Test Double Patterns
+
+### Manual Test Double (Local Class)
+
+```abap
+" Create test double class
+CLASS ltd_mock_reader DEFINITION FOR TESTING.
+  PUBLIC SECTION.
+    INTERFACES zif_data_reader PARTIALLY IMPLEMENTED.
+    METHODS set_result_data
+      IMPORTING it_data TYPE ANY TABLE.
+  PRIVATE SECTION.
+    DATA mt_data TYPE ANY TABLE.
+ENDCLASS.
+
+CLASS ltd_mock_reader IMPLEMENTATION.
+  METHOD set_result_data.
+    mt_data = it_data.
+  ENDMETHOD.
+
+  METHOD zif_data_reader~read_all.
+    rt_data = mt_data.
+  ENDMETHOD.
+ENDCLASS.
+```
+
+### Using ABAP Test Double Framework
+
+```abap
+" Step 1: Declare with correct interface type, then assign
+DATA lo_mock TYPE REF TO zif_my_interface.
+lo_mock ?= cl_abap_testdouble=>create( 'ZIF_MY_INTERFACE' ).
+
+" Step 2: Configure return value - use returning() not IMPORTING
+cl_abap_testdouble=>configure_call( lo_mock )->returning( lo_mock_result ).
+
+" Step 3: Call method to register configuration (MUST use same params in test)
+lo_mock->my_method(
+  EXPORTING
+    iv_param1 = 'value1'
+    iv_param2 = 'value2' ).
+
+" Step 4: In test, call with SAME parameters as registered above
+DATA(ls_result) = lo_mock->my_method(
+  EXPORTING
+    iv_param1 = 'value1'
+    iv_param2 = 'value2' ).
+
+" To raise exception:
+DATA(lx_error) = NEW zcx_my_exception( ).
+cl_abap_testdouble=>configure_call( lo_mock )->raise_exception( lx_error ).
+lo_mock->my_method( ... ).
+```
+
+**Important Notes:**
+- Parameters in configure_call registration MUST match parameters in test execution
+- Always declare variable with interface type first: `DATA lo_mock TYPE REF TO zif_xxx`
+- Use `returning(value = ...)` not `IMPORTING`
+- Call method after configure_call to register the configuration
+
+### Mocking EXPORT Parameters
+
+Some methods use EXPORT parameters instead of returning values. Use `set_parameter`:
+
+```abap
+" Mock EXPORT parameter EI_REPO
+cl_abap_testdouble=>configure_call( lo_repo_srv )->set_parameter(
+  EXPORTING
+    name  = 'EI_REPO'
+    value = lo_repo_double ).
+
+" Register the method call
+lo_repo_srv->get_repo_from_url(
+  EXPORTING iv_url = 'https://github.com/test/repo.git' ).
+```
+
+### Mocking Inherited Methods
+
+When an interface extends another interface, use the parent interface prefix:
+
+```abap
+" zif_abapgit_repo_online extends zif_abapgit_repo
+" Call inherited method with prefix
+lo_repo->zif_abapgit_repo~get_package( ).
+lo_repo->zif_abapgit_repo~refresh( ).
+lo_repo->zif_abapgit_repo~get_files_local( ).
+```
+
+### Mocking Methods with No Parameters
+
+When source code calls a method with no parameters:
+
+```abap
+" Configure returning (no method name)
+cl_abap_testdouble=>configure_call( lo_mock )->returning( lt_data ).
+
+" Register with no parameters (matches source code)
+lo_mock->get_files_local( ).
+```
+
+### Common Mistakes
+
+| Mistake | Correction |
+|---------|------------|
+| Using `IMPORTING` in configure_call | Use `returning()` or `set_parameter()` |
+| Calling method inside configure_call | Call method separately after configure_call |
+| Wrong parameter count | Match exactly what source code calls |
+| Forgot to mock a method | Mock ALL methods the code under test calls |
+| Interface prefix not used | Use `zif_parent~method()` for inherited methods |
+| Didn't check source code first | ALWAYS read source code to see how method is called |
+| Cannot add RAISING to interface method | Use TRY..CATCH to handle exceptions in implementation |
+
+### Handling Exceptions in Interface Implementation
+
+When implementing an interface method that calls other methods raising exceptions:
+
+- **DO NOT** add RAISING to the interface method - you cannot change the interface
+- **USE** TRY..CATCH to catch and handle exceptions within the implementation
+
+```abap
+" Interface method does NOT declare RAISING
+METHOD zif_abgagt_command~execute.
+
+  " Method being called can raise exception
+  TRY.
+      get_user( )->set_repo_git_user_name( ... ).
+    CATCH zcx_abapgit_exception INTO DATA(lx_error).
+      rv_result = '{"error":"' && lx_error->get_text( ) && '"}'.
+      RETURN.
+  ENDTRY.
+
+ENDMETHOD.
+```
+
+### Important: Read Source Code First
+
+**ALWAYS check the source code to see HOW a method is called before writing tests:**
+
+1. Check what parameters are passed (none, some, or all)
+2. Check if optional parameters are used
+3. Check if parameters have default values
+4. Check for type casts (e.g., `li_repo_online ?= li_repo`)
+
+```abap
+" Source code line 122:
+lt_files = li_repo->get_files_local( ).
+
+" Test MUST match - no parameters!
+cl_abap_testdouble=>configure_call( lo_repo )->returning( lt_empty_files ).
+lo_repo->get_files_local( ).  " No parameters!
+```
+
+If the source code calls `get_files_local( )` with no parameters, your test registration must also have no parameters. Even if the method signature has optional parameters, if the source doesn't pass them, your mock registration must not pass them either.
+
+---
+
+## Guidelines for AI Coding Tools
+
+When creating new ABAP classes, ALWAYS follow these rules:
+
+### DO:
+
+1. **Use interfaces for ALL external dependencies**
+   - Database access → interface
+   - External API calls → interface
+   - File I/O → interface
+   - Other services → interface
+
+2. **Pass dependencies via constructor**
+   ```abap
+   METHODS constructor
+     IMPORTING
+       io_agent TYPE REF TO zif_abgagt_agent
+       io_logger TYPE REF TO zif_logger.
+   ```
+
+3. **Define interfaces for all service classes**
+   ```abap
+   " Instead of using class directly
+   DATA mo_agent TYPE REF TO zcl_abgagt_agent.   " BAD
+
+   " Use interface
+   DATA mo_agent TYPE REF TO zif_abgagt_agent.    " GOOD
+   ```
+
+4. **Keep classes FINAL if they don't need mocking**
+   - If a class has no dependencies and doesn't need test doubles, make it FINAL
+   - If a class needs to be mocked in tests, don't make it FINAL
+
+5. **Use dependency injection in command classes**
+   ```abap
+   " Good pattern for command classes
+   CLASS zcl_abgagt_command_pull DEFINITION PUBLIC.
+     PUBLIC SECTION.
+       INTERFACES zif_abgagt_command.
+       METHODS constructor
+         IMPORTING io_agent TYPE REF TO zif_abgagt_agent.
+   ENDCLASS.
+   ```
+
+### DON'T:
+
+1. **Never create dependencies inside methods**
+   ```abap
+   " BAD
+   METHOD execute.
+     lo_agent = NEW zcl_abgagt_agent( ).  " Hardcoded!
+   ENDMETHOD.
+
+   " GOOD
+   METHOD execute.
+     ls_result = mo_agent->pull( ... ).   " Use injected
+   ENDMETHOD.
+   ```
+
+2. **Don't use static method calls for testable code**
+   ```abap
+   " BAD
+   DATA(lo_srv) = zcl_some_srv=>get_instance( ).
+
+   " GOOD - inject the service
+   DATA(lo_srv) = mo_service_provider.
+   ```
+
+3. **Don't make classes FINAL if they need test doubles**
+   - If you need to mock a class in tests, don't declare it FINAL
+
+---
+
+## Example: Refactoring for Testability
+
+### Before (Not Testable)
+
+```abap
+CLASS zcl_abgagt_command_pull DEFINITION PUBLIC.
+  METHOD execute.
+    DATA lo_agent TYPE REF TO zcl_abgagt_agent.
+    lo_agent = NEW zcl_abgagt_agent( ).  " Hardcoded!
+
+    ls_result = lo_agent->pull(
+      iv_url = ls_params-url
+      iv_branch = ls_params-branch ).
+  ENDMETHOD.
+ENDCLASS.
+```
+
+### After (Testable)
+
+```abap
+" Interface for agent
+INTERFACE zif_abgagt_agent PUBLIC.
+  METHODS pull ... RAISING zcx_abapgit_exception.
+ENDINTERFACE.
+
+" Command class with constructor injection
+CLASS zcl_abgagt_command_pull DEFINITION PUBLIC.
+  PUBLIC SECTION.
+    INTERFACES zif_abgagt_command.
+
+    METHODS constructor
+      IMPORTING
+        io_agent TYPE REF TO zif_abgagt_agent OPTIONAL.  " Optional for backward compat
+
+  PRIVATE SECTION.
+    DATA mo_agent TYPE REF TO zif_abgagt_agent.
+
+    METHODS get_agent
+      RETURNING VALUE(ro_agent) TYPE REF TO zif_abgagt_agent.
+ENDCLASS.
+
+CLASS zcl_abgagt_command_pull IMPLEMENTATION.
+
+  METHOD constructor.
+    mo_agent = io_agent.
+  ENDMETHOD.
+
+  METHOD get_agent.
+    " Lazy creation if not injected (for production)
+    IF mo_agent IS NOT BOUND.
+      mo_agent = NEW zcl_abgagt_agent( ).
+    ENDIF.
+    ro_agent = mo_agent.
+  ENDMETHOD.
+
+  METHOD execute.
+    DATA(lo_agent) = get_agent( ).
+    ls_result = lo_agent->pull( ... ).
+  ENDMETHOD.
+
+ENDCLASS.
+```
+
+**Production usage:**
+```abap
+DATA(lo_command) = NEW zcl_abgagt_command_pull(
+  io_agent = NEW zcl_abgagt_agent( ) ).
+```
+
+**Test usage:**
+```abap
+CLASS ltd_mock_agent DEFINITION FOR TESTING.
+  PUBLIC SECTION.
+    INTERFACES zif_abgagt_agent PARTIALLY IMPLEMENTED.
+ENDCLASS.
+
+CLASS ltd_mock_agent IMPLEMENTATION.
+  METHOD zif_abgagt_agent~pull.
+    rs_result-success = abap_true.
+    rs_result-message = 'Mocked success'.
+  ENDMETHOD.
+ENDCLASS.
+
+CLASS ltcl_test DEFINITION FOR TESTING.
+  METHOD test_pull_success.
+    DATA(lo_mock) = NEW ltd_mock_agent( ).
+    DATA(lo_cut) = NEW zcl_abgagt_command_pull( io_agent = lo_mock ).
+
+    DATA(lv_result) = lo_cut->execute( ... ).
+
+    " Assert mocked behavior
+  ENDMETHOD.
+ENDCLASS.
+```
+
+---
+
+## Key Takeaways
+
+1. **Always use interfaces** for dependencies
+2. **Use constructor injection** to pass dependencies
+3. **Never hardcode `NEW` for dependencies** - pass them in
+4. **Avoid static calls** - use instance methods with injected dependencies
+5. **Keep constructors simple** - only assign dependencies
+
+Following these guidelines ensures that:
+- Unit tests can mock all dependencies
+- Tests run fast without external systems
+- Tests are reliable and repeatable
+- Error conditions can be tested easily
+- Code is modular and loosely coupled

package/bin/abapgit-agent

@@ -538,12 +538,14 @@ async function processInspectResult(res) {
   const errorCount = res.ERROR_COUNT !== undefined ? res.ERROR_COUNT : (res.error_count || 0);
   const errors = res.ERRORS !== undefined ? res.ERRORS : (res.errors || []);
   const warnings = res.WARNINGS !== undefined ? res.WARNINGS : (res.warnings || []);
+  const infos = res.INFOS !== undefined ? res.INFOS : (res.infos || []);
 
-  if (errorCount > 0 || warnings.length > 0) {
+  if (errorCount > 0 || warnings.length > 0 || infos.length > 0) {
     if (errorCount > 0) {
       console.log(`❌ ${objectType} ${objectName} - Syntax check failed (${errorCount} error(s)):`);
     } else {
-      console.log(`⚠️  ${objectType} ${objectName} - Syntax check passed with warnings (${warnings.length}):`);
+      const total = warnings.length + infos.length;
+      console.log(`⚠️  ${objectType} ${objectName} - Syntax check passed with warnings (${total}):`);
     }
     console.log('\nErrors:');
     console.log('─'.repeat(60));
@@ -552,8 +554,16 @@ async function processInspectResult(res) {
       const line = err.LINE || err.line || '?';
       const column = err.COLUMN || err.column || '?';
       const text = err.TEXT || err.text || 'Unknown error';
+      const methodName = err.METHOD_NAME || err.method_name;
+      const sobjname = err.SOBJNAME || err.sobjname;
 
+      if (methodName) {
+        console.log(`  Method: ${methodName}`);
+      }
       console.log(`  Line ${line}, Column ${column}:`);
+      if (sobjname && sobjname.includes('====')) {
+        console.log(`    Include: ${sobjname}`);
+      }
       console.log(`    ${text}`);
       console.log('');
     }
@@ -565,7 +575,38 @@ async function processInspectResult(res) {
       for (const warn of warnings) {
         const line = warn.LINE || warn.line || '?';
         const text = warn.MESSAGE || warn.message || 'Unknown warning';
-        console.log(`  Line ${line}: ${text}`);
+        const methodName = warn.METHOD_NAME || warn.method_name;
+        const sobjname = warn.SOBJNAME || warn.sobjname;
+
+        if (methodName) {
+          console.log(`  Method: ${methodName}`);
+        }
+        console.log(`  Line ${line}:`);
+        if (sobjname && sobjname.includes('====')) {
+          console.log(`    Include: ${sobjname}`);
+        }
+        console.log(`    ${text}`);
+      }
+    }
+
+    // Show infos if any
+    if (infos.length > 0) {
+      console.log('Info:');
+      console.log('─'.repeat(60));
+      for (const info of infos) {
+        const line = info.LINE || info.line || '?';
+        const text = info.MESSAGE || info.message || 'Unknown info';
+        const methodName = info.METHOD_NAME || info.method_name;
+        const sobjname = info.SOBJNAME || info.sobjname;
+
+        if (methodName) {
+          console.log(`  Method: ${methodName}`);
+        }
+        console.log(`  Line ${line}:`);
+        if (sobjname && sobjname.includes('====')) {
+          console.log(`    Include: ${sobjname}`);
+        }
+        console.log(`    ${text}`);
       }
     }
   } else if (success === true || success === 'X') {
@@ -652,7 +693,7 @@ async function runUnitTests(options) {
 /**
  * Run unit test for a single file
  */
-async function runUnitTestForFile(sourceFile, csrfToken, config) {
+async function runUnitTestForFile(sourceFile, csrfToken, config, coverage = false) {
   console.log(`  Running unit test for: ${sourceFile}`);
 
   try {
@@ -687,7 +728,8 @@ async function runUnitTestForFile(sourceFile, csrfToken, config) {
 
     // Send files array to unit endpoint (ABAP expects string_table of file names)
     const data = {
-      files: [sourceFile]
+      files: [sourceFile],
+      coverage: coverage
     };
 
     const result = await request('POST', '/sap/bc/z_abapgit_agent/unit', data, { csrfToken });
@@ -700,6 +742,9 @@ async function runUnitTestForFile(sourceFile, csrfToken, config) {
     const message = result.MESSAGE || result.message || '';
     const errors = result.ERRORS || result.errors || [];
 
+    // Handle coverage data
+    const coverageStats = result.COVERAGE_STATS || result.coverage_stats;
+
     if (testCount === 0) {
       console.log(`  ➖ ${objName} - No unit tests`);
     } else if (success === 'X' || success === true) {
@@ -710,6 +755,17 @@ async function runUnitTestForFile(sourceFile, csrfToken, config) {
 
     console.log(`     Tests: ${testCount} | Passed: ${passedCount} | Failed: ${failedCount}`);
 
+    // Display coverage if available
+    if (coverage && coverageStats) {
+      const totalLines = coverageStats.TOTAL_LINES || coverageStats.total_lines || 0;
+      const coveredLines = coverageStats.COVERED_LINES || coverageStats.covered_lines || 0;
+      const coverageRate = coverageStats.COVERAGE_RATE || coverageStats.coverage_rate || 0;
+
+      console.log(`     📊 Coverage: ${coverageRate}%`);
+      console.log(`        Total Lines: ${totalLines}`);
+      console.log(`        Covered Lines: ${coveredLines}`);
+    }
+
     if (failedCount > 0 && errors.length > 0) {
       for (const err of errors) {
         const className = err.CLASS_NAME || err.class_name || '?';
@@ -1727,21 +1783,25 @@ Examples:
         const filesArgIndex = args.indexOf('--files');
         if (filesArgIndex === -1 || filesArgIndex + 1 >= args.length) {
           console.error('Error: --files parameter required');
-          console.error('Usage: abapgit-agent unit --files <file1>,<file2>,...');
+          console.error('Usage: abapgit-agent unit --files <file1>,<file2>,... [--coverage]');
           console.error('Example: abapgit-agent unit --files zcl_my_test.clas.abap');
+          console.error('Example: abapgit-agent unit --files zcl_my_test.clas.abap --coverage');
           process.exit(1);
         }
 
         const files = args[filesArgIndex + 1].split(',').map(f => f.trim());
 
-        console.log(`\n  Running unit tests for ${files.length} file(s)`);
+        // Check for coverage option
+        const coverage = args.includes('--coverage');
+
+        console.log(`\n  Running unit tests for ${files.length} file(s)${coverage ? ' (with coverage)' : ''}`);
         console.log('');
 
         const config = loadConfig();
         const csrfToken = await fetchCsrfToken(config);
 
         for (const sourceFile of files) {
-          await runUnitTestForFile(sourceFile, csrfToken, config);
+          await runUnitTestForFile(sourceFile, csrfToken, config, coverage);
         }
         break;
       }
@@ -2452,32 +2512,10 @@ Examples:
         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;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abapgit-agent",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "description": "ABAP Git Agent - Pull and activate ABAP code via abapGit from any git repository",
   "main": "src/index.js",
   "files": [

package/src/config.js

@@ -24,7 +24,7 @@ function loadConfig() {
   if (fs.existsSync(configPath)) {
     config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
   } else {
-    // Load from environment variables
+    // Load from environment variables only when no config file exists
     config = {
       host: process.env.ABAP_HOST,
       sapport: parseInt(process.env.ABAP_PORT, 10) || 443,

package/src/ref-search.js

@@ -257,79 +257,117 @@ async function getSearchableFiles(repoPath, repoName, extensions = ['.md', '.aba
 }
 
 /**
- * Search for a pattern across all reference repositories
+ * Search for a pattern across all reference repositories and local guidelines
  * @param {string} pattern - Pattern to search for
  * @returns {Promise<Object>} Search results
  */
 async function searchPattern(pattern) {
   const refFolder = detectReferenceFolder();
   const repos = await getReferenceRepositories();
+  const guidelinesFolder = detectGuidelinesFolder();
 
-  if (!refFolder) {
+  // If neither reference folder nor guidelines exist, return error
+  if (!refFolder && !guidelinesFolder) {
     return {
       error: 'Reference folder not found',
-      hint: 'Configure referenceFolder in .abapGitAgent or clone to ~/abap-reference'
-    };
-  }
-
-  if (repos.length === 0) {
-    return {
-      error: 'No ABAP repositories found in reference folder',
-      hint: 'Clone ABAP repositories to the reference folder to enable searching'
+      hint: 'Configure referenceFolder in .abapGitAgent, clone to ~/abap-reference, or create abap/guidelines/ folder'
     };
   }
 
   const results = {
     pattern,
     referenceFolder: refFolder,
+    guidelinesFolder: guidelinesFolder,
     repositories: repos.map(r => r.name),
     files: [],
     matches: []
   };
 
   try {
-    // Search across all repositories
-    for (const repo of repos) {
-      const searchableFiles = await getSearchableFiles(repo.path, repo.name);
+    // Search reference repositories if available
+    if (repos.length > 0) {
+      for (const repo of repos) {
+        const searchableFiles = await getSearchableFiles(repo.path, repo.name);
+
+        for (const fileInfo of searchableFiles) {
+          try {
+            const content = await readFile(fileInfo.path, 'utf8');
+
+            if (content.toLowerCase().includes(pattern.toLowerCase())) {
+              results.files.push({
+                repo: repo.name,
+                file: fileInfo.relativePath
+              });
+
+              // Find matching lines with context
+              const lines = content.split('\n');
+              let matchCount = 0;
+
+              for (let i = 0; i < lines.length; i++) {
+                if (lines[i].toLowerCase().includes(pattern.toLowerCase())) {
+                  const start = Math.max(0, i - 1);
+                  const end = Math.min(lines.length, i + 2);
+                  const context = lines.slice(start, end).join('\n');
+
+                  results.matches.push({
+                    repo: repo.name,
+                    file: fileInfo.relativePath,
+                    line: i + 1,
+                    context
+                  });
+
+                  matchCount++;
+
+                  // Limit matches per file to avoid overwhelming output
+                  if (matchCount >= 3) {
+                    break;
+                  }
+                }
+              }
+            }
+          } catch (error) {
+            // Skip files we can't read
+          }
+        }
+      }
+    }
 
-      for (const fileInfo of searchableFiles) {
-        try {
-          const content = await readFile(fileInfo.path, 'utf8');
+    // Search local guidelines folder if available
+    if (guidelinesFolder) {
+      const guidelineFiles = await getGuidelineFiles();
 
-          if (content.toLowerCase().includes(pattern.toLowerCase())) {
-            results.files.push({
-              repo: repo.name,
-              file: fileInfo.relativePath
-            });
+      for (const file of guidelineFiles) {
+        if (file.content.toLowerCase().includes(pattern.toLowerCase())) {
+          results.files.push({
+            repo: 'guidelines',
+            file: file.relativePath
+          });
 
-            // Find matching lines with context
-            const lines = content.split('\n');
-            let matchCount = 0;
+          // Find matching lines with context
+          const lines = file.content.split('\n');
+          let matchCount = 0;
 
-            for (let i = 0; i < lines.length; i++) {
-              if (lines[i].toLowerCase().includes(pattern.toLowerCase())) {
-                const start = Math.max(0, i - 1);
-                const end = Math.min(lines.length, i + 2);
-                const context = lines.slice(start, end).join('\n');
+          for (let i = 0; i < lines.length; i++) {
+            if (lines[i].toLowerCase().includes(pattern.toLowerCase())) {
+              const start = Math.max(0, i - 1);
+              const end = Math.min(lines.length, i + 2);
+              const context = lines.slice(start, end).join('\n');
 
-                results.matches.push({
-                  repo: repo.name,
-                  file: fileInfo.relativePath,
-                  line: i + 1,
-                  context
-                });
+              results.matches.push({
+                repo: 'guidelines',
+                file: file.relativePath,
+                line: i + 1,
+                context
+              });
 
-                matchCount++;
+              matchCount++;
 
-                // Limit matches per file to avoid overwhelming output
-                if (matchCount >= 3) {
-                  break;
-                }
+              // Limit matches per file to avoid overwhelming output
+              if (matchCount >= 3) {
+                break;
               }
             }
           }
-        } catch (error) {
-          // Skip files we can't read
         }
       }
     }
@@ -469,7 +507,16 @@ function displaySearchResults(results) {
   }
 
   console.log(`\n  🔍 Searching for: '${results.pattern}'`);
-  console.log(`  📁 Reference folder: ${results.referenceFolder}`);
+
+  // Show which sources were searched
+  const sources = [];
+  if (results.referenceFolder) {
+    sources.push('reference repositories');
+  }
+  if (results.guidelinesFolder) {
+    sources.push('local guidelines');
+  }
+  console.log(`  📁 Sources searched: ${sources.join(', ') || 'none'}`);
 
   if (results.repositories && results.repositories.length > 0) {
     console.log(`  📚 Repositories (${results.repositories.length}): ${results.repositories.join(', ')}`);
@@ -491,7 +538,8 @@ function displaySearchResults(results) {
 
   console.log(`  ✅ Found in ${results.files.length} file(s):`);
   for (const [repo, files] of Object.entries(filesByRepo)) {
-    console.log(`\n     📦 ${repo}/`);
+    const icon = repo === 'guidelines' ? '📋' : '📦';
+    console.log(`\n     ${icon} ${repo}/`);
     files.forEach(file => {
       console.log(`        • ${file}`);
     });