opencode-auto-agent 1.0.0

package/templates/presets/springboot.md

@@ -0,0 +1,69 @@
+# Preset: Spring Boot
+
+Extends the Java preset with Spring Boot-specific conventions.
+
+## Framework
+- Spring Boot 3.x (Java 17+)
+- Spring Web MVC or WebFlux (detect from dependencies)
+- Spring Data JPA (if relational DB)
+
+## Project Structure Conventions
+```
+src/main/java/com/example/app/
+  config/          # @Configuration classes
+  controller/      # @RestController classes
+  service/         # @Service classes (business logic)
+  repository/      # @Repository interfaces (data access)
+  model/           # @Entity / DTO classes
+  exception/       # Custom exceptions + @ControllerAdvice
+  security/        # Security config (if applicable)
+src/main/resources/
+  application.yml  # or application.properties
+  db/migration/    # Flyway/Liquibase migrations
+src/test/java/
+  ...              # Mirror of main structure
+```
+
+## Naming Conventions
+- Controllers: `<Entity>Controller` (e.g., `UserController`)
+- Services: `<Entity>Service` / `<Entity>ServiceImpl`
+- Repositories: `<Entity>Repository`
+- DTOs: `<Entity>Request`, `<Entity>Response`
+- Entities: match domain model name (e.g., `User`, `Order`)
+- Config: `<Feature>Config` (e.g., `SecurityConfig`)
+
+## Testing Expectations
+- Unit tests: JUnit 5 + Mockito for service layer
+- Integration tests: `@SpringBootTest` for controller + full stack
+- Slice tests: `@WebMvcTest`, `@DataJpaTest` for isolated layers
+- Run: `mvn test` or `gradle test`
+- Test database: H2 in-memory or Testcontainers
+- API tests: use MockMvc for controller tests
+
+## Build & Verification
+- Build: `mvn clean package -DskipTests` (compile check) or `gradle build`
+- Full verify: `mvn verify` or `gradle check`
+- Run: `mvn spring-boot:run` or `gradle bootRun`
+- Check actuator health: `GET /actuator/health`
+
+## Spring-Specific Rules
+- Use constructor injection (not field injection with `@Autowired`)
+- Use `@Transactional` at the service layer, not the controller
+- Return `ResponseEntity<>` from controllers for explicit HTTP status control
+- Use DTOs for API input/output — do not expose entities directly
+- Use `@Valid` / `@Validated` for request body validation
+- Configure CORS via `WebMvcConfigurer`, not per-controller annotations
+- Put sensitive config in environment variables, not `application.yml`
+
+## API Conventions
+- REST endpoints: `GET /api/v1/users`, `POST /api/v1/users`, etc.
+- Use plural nouns for resource paths
+- Return appropriate HTTP status codes (201 for creation, 204 for delete, etc.)
+- Use `@ExceptionHandler` / `@ControllerAdvice` for consistent error responses
+
+## Common Pitfalls
+- Do not use `@Autowired` on fields — use constructor injection
+- Do not put business logic in controllers — delegate to services
+- Do not return JPA entities directly from controllers — use DTOs
+- Do not forget to add `@Transactional(readOnly = true)` for read-only queries
+- Do not hardcode profiles — use `application-{profile}.yml`

package/templates/rules/universal.md

@@ -0,0 +1,31 @@
+# Universal Engineering Rules
+
+These rules apply to ALL agents in ALL presets. They are non-negotiable.
+
+## Process Rules
+1. **Plan before coding.** Every non-trivial change must have a plan reviewed before implementation begins.
+2. **Test after implementing.** No implementation step is complete until tests pass.
+3. **Review before merging.** Code review is mandatory for all changes.
+4. **One thing at a time.** Complete one task fully (plan → implement → test → verify) before starting the next.
+
+## Code Quality Rules
+1. **Keep changes minimal.** Only modify what the task requires. Do not refactor unrelated code.
+2. **No dead code.** Do not leave commented-out code, unused imports, or unreachable branches.
+3. **No hardcoded secrets.** Never commit passwords, API keys, tokens, or connection strings.
+4. **Consistent naming.** Follow the project's existing naming conventions. When in doubt, read nearby code.
+5. **Error handling.** All external calls (I/O, network, parsing) must have error handling.
+
+## Documentation Rules
+1. **Update docs when behavior changes.** If the public interface or behavior changes, docs must be updated in the same task.
+2. **Do not duplicate.** Reference existing documentation rather than repeating it.
+3. **Keep README current.** Setup instructions, environment variables, and usage examples must stay accurate.
+
+## Communication Rules
+1. **Be specific.** Reference file paths and line numbers, not vague descriptions.
+2. **Report blockers immediately.** If a step cannot be completed, say so with a clear reason.
+3. **Structured output.** Use the output format defined in your agent specification.
+
+## Context Rules
+1. **Always load context first.** Read the runtime context file before starting any work.
+2. **Respect the preset.** Framework-specific rules in the active preset override general conventions.
+3. **Read existing code.** Understand what exists before creating something new.

package/templates/sample-config.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://github.com/ai-starter-kit/config-schema",
+  "version": "0.1.0",
+  "preset": "java",
+  "docsPath": "./Docs",
+  "tasksPath": "./PRD.md",
+  "outputPath": "./",
+  "engine": "opencode",
+  "agents": {
+    "orchestrator": { "enabled": true },
+    "planner": { "enabled": true },
+    "developer": { "enabled": true },
+    "qa": { "enabled": true },
+    "reviewer": { "enabled": true },
+    "docs": { "enabled": true }
+  },
+  "orchestrator": {
+    "workflowSteps": ["plan", "implement", "test", "verify"],
+    "requirePlanApproval": false
+  }
+}