agent-workflow-kit-cli 1.0.0-mvp → 1.2.0

package/templates/spring-boot/skills/spring-debug/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: spring-debug
+description: Systematically diagnoses and fixes a Java Spring Boot bug or runtime error
+---
+
+Follow this workflow to diagnose, reproduce, and resolve a bug or test failure in the Spring Boot application.
+
+Inputs:
+- errorMessage: Stack trace, error logs, or problem description
+- componentName: Name of the suspected class, package, or API endpoint
+
+Steps:
+1. **Analyze Exception Stack Traces:**
+   - Read the logs to identify the root cause exception type (e.g., `NullPointerException`, `DataIntegrityViolationException`, `LazyInitializationException`).
+   - Trace the error to the specific line number in the codebase.
+
+2. **Isolate and Create a Reproducer Test Case:**
+   - Before editing the code, write a minimal unit test (in `src/test/java/`) that reproduces the error.
+   - For Controller errors: Add a test inside the corresponding `@WebMvcTest`.
+   - For DB/Repository query errors: Add a test inside the corresponding `@DataJpaTest`.
+   - Run the test and confirm it fails with the reported exception.
+
+3. **Check Database Queries & Configurations:**
+   - If the error involves data persistence, check the console output or enable Hibernate SQL logs:
+     `logging.level.org.hibernate.SQL: DEBUG`
+   - Inspect database constraints (e.g., non-null columns, unique constraints, foreign keys) and compare them with JPA Entity annotations.
+
+4. **Verify Transactions & Proxies:**
+   - Verify if `@Transactional` is declared correctly. Check if the error is caused by self-invocation traps (calling transactional methods from within the same class).
+
+5. **Apply the Fix & Re-Verify:**
+   - Fix the bug in the code.
+   - Run the reproducer test case to verify it now passes.
+   - Run the full project verification command:
+     - `{{buildCommand}} clean test`

package/templates/spring-boot/skills/spring-feature/SKILL.md

@@ -11,16 +11,28 @@ Inputs:
 
 Steps:
 1. Examine neighboring feature packages for error handler conventions and mappings.
-2. Create the target feature package under the designated project folder.
+2. Identify or create the target packages under `src/main/java/{{packagePath}}`.
 3. Implement layers:
-   - `entity/`: Database models.
-   - `repository/`: Spring Data JPA interface.
-   - `dto/`: Request/Response schemas with jakarta.validation annotations.
-   - `service/`: Service interfaces and implementations.
-   - `web/`: Controller class exposing `@RestController` with proper mappings.
-4. Create tests:
-   - Service Unit Tests using Mockito.
-   - `@WebMvcTest` for Controller routing, payloads, and validation.
-   - `@DataJpaTest` for custom queries.
-5. Run validations:
-   - `./mvnw verify`
+{{#if (eq packageLayout "feature-first")}}
+   - `entity/`: Database models inside the feature package (`src/main/java/{{packagePath}}/\{{featureName}}/entity/`).
+   - `repository/`: Spring Data JPA interface inside the feature package (`src/main/java/{{packagePath}}/\{{featureName}}/repository/`).
+   - `dto/`: Request/Response schemas with `{{validationLibrary}}` annotations (`src/main/java/{{packagePath}}/\{{featureName}}/dto/`).
+   - `service/`: Service interfaces and implementations (`src/main/java/{{packagePath}}/\{{featureName}}/service/`).
+   - `web/`: Controller class exposing `@RestController` with proper mappings (`src/main/java/{{packagePath}}/\{{featureName}}/web/`).
+{{else}}
+   - `entity/`: Database models under `src/main/java/{{packagePath}}/entity/`.
+   - `repository/`: Spring Data JPA interface under `src/main/java/{{packagePath}}/repository/`.
+   - `dto/`: Request/Response schemas with `{{validationLibrary}}` annotations under `src/main/java/{{packagePath}}/dto/`.
+   - `service/`: Service interfaces and implementations under `src/main/java/{{packagePath}}/service/`.
+   - `web/`: Controller class under `src/main/java/{{packagePath}}/controller/`.
+{{/if}}
+4. Create comprehensive tests (using {{testFramework}}):
+   - **Service Unit Tests**: Mock repository and downstream dependencies using Mockito. Cover the main happy path, exception handling branches, null parameters, and boundary conditions.
+   - **Controller Slice Tests (`@WebMvcTest`)**: Verify routing paths, payload serialization, and constraint validation errors. Ensure you test invalid inputs (e.g. missing fields, out of bound size values, incorrect formats) and verify they return HTTP 400 or appropriate error responses.
+   - **Repository Slice Tests (`@DataJpaTest`)**: Verify custom database query logic and entity-column bindings.
+5. Perform Code Quality & Production Readiness Checks:
+   - Review your changes against `@code-review.md` to check transaction boundaries (`@Transactional`), avoid swallowed exceptions, check thread safety, and prevent SQL injection.
+   - Verify that any database schema changes are added as migration scripts, and configurations are profile-isolated under `@production-ready.md`.
+6. Run validations:
+   - `{{buildCommand}} clean test`
+   - `{{buildCommand}} {{buildVerifyArgs}}`