incremental-java-programmer

# Incremental Java Programmer

## Overview

Implement new features in Java repositories by analyzing the codebase, generating implementation code, creating comprehensive tests, and ensuring all tests pass before completion.

## Workflow

### 1. Analyze Repository Structure

Understand the Java project structure and build system:

**Identify build system**:
- Maven: Look for `pom.xml` in root directory
- Gradle: Look for `build.gradle` or `build.gradle.kts`

**Examine project structure**:
```
src/
├── main/
│   └── java/
│       └── com/example/project/
│           ├── model/
│           ├── service/
│           ├── controller/
│           └── util/
└── test/
    └── java/
        └── com/example/project/
            ├── model/
            ├── service/
            └── controller/
```

**Extract key information**:
- Package structure and naming conventions
- Existing class hierarchy and relationships
- Dependencies from `pom.xml` or `build.gradle`
- Testing framework (JUnit 4, JUnit 5, TestNG)
- Code style and patterns used in the project

### 2. Parse Feature Description

Break down the natural language feature description into actionable components:

**Identify feature type**:
- **New functionality**: Adding entirely new capabilities
- **Enhancement**: Extending existing functionality
- **Modification**: Changing existing behavior

**Extract requirements**:
- What classes/methods need to be created or modified
- Input parameters and return types
- Business logic and validation rules
- Error handling requirements
- Integration points with existing code

**Example feature description**:
```
"Add a method to calculate the total price of items in a shopping cart,
including tax. The tax rate should be configurable. If the cart is empty,
return 0. The method should throw an exception if the tax rate is negative."
```

**Parsed components**:
- Target class: `ShoppingCart`
- New method: `calculateTotalWithTax(double taxRate)`
- Return type: `double`
- Validation: Check for negative tax rate, handle empty cart
- Exception: `IllegalArgumentException` for negative tax rate

### 3. Locate Target Files

Find where the implementation should be added:

**For new classes**:
- Determine appropriate package based on functionality
- Follow existing package structure conventions
- Place in `src/main/java/[package-path]/`

**For existing classes**:
- Use Grep to find the target class
- Read the class to understand current structure
- Identify where new methods should be added

**For modifications**:
- Locate the specific method to modify
- Understand current implementation
- Plan minimal changes to achieve feature

### 4. Implement Feature Code

Write Java code following project conventions:

**Code structure**:
```java
/**
 * [Javadoc description of what the method does]
 *
 * @param paramName description of parameter
 * @return description of return value
 * @throws ExceptionType description of when exception is thrown
 */
public ReturnType methodName(ParamType paramName) {
    // Input validation
    if (invalidCondition) {
        throw new IllegalArgumentException("Error message");
    }

    // Business logic
    ReturnType result = performCalculation();

    // Return result
    return result;
}
```

**Best practices**:
- Follow existing code style (indentation, naming, formatting)
- Add comprehensive Javadoc comments
- Include input validation
- Handle edge cases
- Use appropriate access modifiers
- Follow SOLID principles
- Avoid code duplication

**For new classes**:
```java
package com.example.project.service;

import java.util.List;

/**
 * Service class for managing shopping cart operations.
 */
public class ShoppingCartService {

    private final TaxCalculator taxCalculator;

    public ShoppingCartService(TaxCalculator taxCalculator) {
        this.taxCalculator = taxCalculator;
    }

    // Methods here
}
```

### 5. Generate Unit Tests

Create comprehensive JUnit tests for the new functionality:

**Test class structure**:
```java
package com.example.project.service;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;
import static org.junit.jupiter.api.Assertions.*;

class ShoppingCartServiceTest {

    private ShoppingCartService service;

    @BeforeEach
    void setUp() {
        service = new ShoppingCartService(new TaxCalculator());
    }

    @Test
    @DisplayName("Should calculate total with tax correctly")
    void testCalculateTotalWithTax() {
        // Arrange
        double subtotal = 100.0;
        double taxRate = 0.08;

        // Act
        double result = service.calculateTotalWithTax(subtotal, taxRate);

        // Assert
        assertEquals(108.0, result, 0.01);
    }

    @Test
    @DisplayName("Should throw exception for negative tax rate")
    void testNegativeTaxRate() {
        assertThrows(IllegalArgumentException.class, () -> {
            service.calculateTotalWithTax(100.0, -0.05);
        });
    }

    @Test
    @DisplayName("Should return zero for empty cart")
    void testEmptyCart() {
        double result = service.calculateTotalWithTax(0.0, 0.08);
        assertEquals(0.0, result, 0.01);
    }
}
```

**Test coverage requirements**:
- Happy path (normal operation)
- Edge cases (empty inputs, boundary values)
- Error cases (invalid inputs, exceptions)
- Integration with existing code

**Test naming conventions**:
- Use descriptive test method names
- Follow project's existing test naming pattern
- Use `@DisplayName` for readable test descriptions

### 6. Update Existing Tests

Modify existing tests if the feature changes existing behavior:

**Identify affected tests**:
- Search for tests that call modified methods
- Find tests that assert on changed behavior
- Locate integration tests that may be affected

**Update test assertions**:
```java
// Before
assertEquals(100.0, cart.getTotal());

// After (if feature adds tax calculation)
assertEquals(108.0, cart.getTotalWithTax(0.08));
```

**