Amp Agent SDK

<dependencies>
    <!-- Core AgentClient API -->
    <dependency>
        <groupId>org.springaicommunity.agents</groupId>
        <artifactId>spring-ai-agent-client</artifactId>
        <version>0.1.0-SNAPSHOT</version>
    </dependency>

    <!-- Amp integration -->
    <dependency>
        <groupId>org.springaicommunity.agents</groupId>
        <artifactId>spring-ai-amp-agent</artifactId>
        <version>0.1.0-SNAPSHOT</version>
    </dependency>
</dependencies>

<dependency>
    <groupId>org.springaicommunity.agents</groupId>
    <artifactId>spring-ai-starter-agent-amp</artifactId>
    <version>0.1.0-SNAPSHOT</version>
</dependency>

import org.springaicommunity.agents.client.AgentClient;
import org.springaicommunity.agents.client.AgentClientResponse;
import org.springaicommunity.agents.amp.AmpAgentModel;
import org.springaicommunity.agents.amp.AmpAgentOptions;
import org.springaicommunity.agents.ampsdk.AmpClient;

import java.nio.file.Paths;

public class AmpExample {
    public static void main(String[] args) {
        // 1. Create the Amp client
        AmpClient ampClient = AmpClient.create(
            Paths.get(System.getProperty("user.dir"))
        );

        // 2. Configure agent options
        AmpAgentOptions options = AmpAgentOptions.builder()
            .model("amp-default")
            .dangerouslyAllowAll(true)
            .build();

        // 3. Create the agent model
        AmpAgentModel agentModel = new AmpAgentModel(ampClient, options);

        // 4. Create AgentClient
        AgentClient agentClient = AgentClient.create(agentModel);

        // 5. Execute a goal
        AgentClientResponse response = agentClient.run(
            "Create a simple Calculator class with add, subtract, multiply, and divide methods"
        );

        System.out.println("Result: " + response.getResult());
        System.out.println("Success: " + response.isSuccessful());
    }
}

// Create with default working directory
AmpClient client = AmpClient.create();

// Create with specific working directory
Path projectPath = Paths.get("/path/to/project");
AmpClient client = AmpClient.create(projectPath);

// Create with custom Amp CLI path
AmpClient client = AmpClient.create(
    projectPath,
    "/custom/path/to/amp"
);

AmpAgentOptions options = AmpAgentOptions.builder()
    // Model selection (currently only amp-default available)
    .model("amp-default")

    // Execution settings
    .dangerouslyAllowAll(true)            // Allow modifications
    .timeout(Duration.ofMinutes(10))      // Execution timeout

    // CLI path (for non-standard installations)
    .executablePath("/custom/path/to/amp")

    .build();

// Configure working directory via client
AmpClient client = AmpClient.create(
    Paths.get("/path/to/microservice")
);

// Or via AgentClient fluent API
AgentClientResponse response = agentClient
    .goal("Add validation to the UserController")
    .workingDirectory("/path/to/microservice")
    .run();

// Development mode - allow changes
AmpAgentOptions devOptions = AmpAgentOptions.builder()
    .dangerouslyAllowAll(true)
    .build();

// Analysis mode - read-only
AmpAgentOptions analysisOptions = AmpAgentOptions.builder()
    .dangerouslyAllowAll(false)
    .build();

// Quick tasks
AmpAgentOptions quickOptions = AmpAgentOptions.builder()
    .timeout(Duration.ofMinutes(2))
    .build();

// Complex refactoring
AmpAgentOptions complexOptions = AmpAgentOptions.builder()
    .timeout(Duration.ofMinutes(30))
    .build();

import org.springaicommunity.agents.ampsdk.exceptions.AmpSDKException;

try {
    AgentClientResponse response = agentClient.run("Complex refactoring goal");

    if (!response.isSuccessful()) {
        System.err.println("Goal failed: " + response.getResult());
    }

} catch (AmpSDKException e) {
    // Amp CLI process failed
    System.err.println("Amp execution error: " + e.getMessage());

} catch (RuntimeException e) {
    // Other runtime errors (timeout, etc.)
    System.err.println("Unexpected error: " + e.getMessage());
}

@Service
public class AmpService {

    private final AgentClient agentClient;

    public AmpService(AgentClient agentClient) {
        this.agentClient = agentClient;
    }

    public String refactorCode(String className, String requirements) {
        // Validate inputs
        if (className == null || className.trim().isEmpty()) {
            throw new IllegalArgumentException("Class name is required");
        }

        try {
            // First, analyze the code
            AgentClientResponse analysis = agentClient
                .goal("Analyze " + className + " and suggest improvements")
                .options(AmpAgentOptions.builder()
                    .dangerouslyAllowAll(false) // Read-only
                    .build())
                .run();

            if (!analysis.isSuccessful()) {
                throw new ServiceException("Analysis failed: " + analysis.getResult());
            }

            // Then perform refactoring
            AgentClientResponse refactoring = agentClient
                .goal("Refactor " + className + " based on: " + requirements)
                .options(AmpAgentOptions.builder()
                    .dangerouslyAllowAll(true) // Allow modifications
                    .build())
                .run();

            return refactoring.getResult();

        } catch (Exception e) {
            // Log error and return meaningful message
            log.error("Refactoring failed for class: {}", className, e);
            throw new ServiceException("Unable to refactor " + className + ": " + e.getMessage());
        }
    }
}

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    // AmpClient, AmpAgentModel, and AgentClient are auto-configured

    @Bean
    public CommandLineRunner demo(AgentClient agentClient) {
        return args -> {
            AgentClientResponse response = agentClient.run(
                "Create a REST controller for managing users"
            );
            System.out.println(response.getResult());
        };
    }
}

spring:
  ai:
    agents:
      amp:
        model: amp-default
        timeout: PT10M
        dangerously-allow-all: false
        executable-path: /custom/path/to/amp  # Optional

spring.ai.agents.amp.model=amp-default
spring.ai.agents.amp.timeout=PT10M
spring.ai.agents.amp.dangerously-allow-all=false
spring.ai.agents.amp.executable-path=/custom/path/to/amp

@Configuration
public class AmpConfiguration {

    @Bean
    public AmpAgentOptions customAmpOptions() {
        return AmpAgentOptions.builder()
            .model("amp-default")
            .dangerouslyAllowAll(true)
            .timeout(Duration.ofMinutes(15))
            .build();
    }

    @Bean
    public AmpClient customAmpClient() {
        return AmpClient.create(
            Paths.get("/path/to/project"),
            "/custom/path/to/amp"
        );
    }
}

// Good: Specific and contextual
agentClient.run("Add input validation to UserController.createUser() method using Bean Validation annotations");

// Good: Clear scope and requirements
agentClient.run("Refactor PaymentService to use the Strategy pattern for different payment processors");

// Avoid: Vague requests
agentClient.run("Fix the code");

// Avoid: Overly broad scope
agentClient.run("Rewrite the entire application");

@Profile("development")
@Configuration
public class DevelopmentAmpConfig {

    @Bean
    public AmpAgentOptions devAmpOptions() {
        return AmpAgentOptions.builder()
            .dangerouslyAllowAll(true) // OK for development
            .build();
    }
}

@Profile("production")
@Configuration
public class ProductionAmpConfig {

    @Bean
    public AmpAgentOptions prodAmpOptions() {
        return AmpAgentOptions.builder()
            .dangerouslyAllowAll(false) // Safe for production
            .build();
    }
}

@Component
public class AmpMonitor {

    private final MeterRegistry meterRegistry;
    private final AgentClient agentClient;

    public AmpMonitor(MeterRegistry meterRegistry, AgentClient agentClient) {
        this.meterRegistry = meterRegistry;
        this.agentClient = agentClient;
    }

    public String executeWithMetrics(String goal) {
        return Timer.Sample.start(meterRegistry)
            .stop(Timer.builder("amp.goal.duration")
                .tag("goal", goal.substring(0, Math.min(goal.length(), 50)))
                .register(meterRegistry))
            .recordCallable(() -> {
                Counter.builder("amp.goal.count").register(meterRegistry).increment();

                AgentClientResponse response = agentClient.run(goal);

                Counter.builder("amp.goal.result")
                    .tag("success", String.valueOf(response.isSuccessful()))
                    .register(meterRegistry)
                    .increment();

                return response.getResult();
            });
    }
}

# Verify installation
amp --version

# Check PATH
which amp  # macOS/Linux
where amp  # Windows

# Set AMP_CLI_PATH for custom installation
export AMP_CLI_PATH=/path/to/amp

# Check environment variable
echo $AMP_API_KEY

# Test with Amp CLI directly
amp --help

# Or use session authentication
amp login

# Check directory permissions
ls -la /path/to/project

# Fix if needed
chmod -R u+rw /path/to/project

AmpAgentOptions options = AmpAgentOptions.builder()
    .timeout(Duration.ofMinutes(30)) // Longer timeout
    .build();

# Test manually
echo "Create a file test.txt" | amp --dangerously-allow-all -x

logging:
  level:
    org.springaicommunity.agents.amp: DEBUG
    org.springaicommunity.agents.ampsdk: DEBUG
    org.springaicommunity.agents.client: DEBUG