Decoupling System prompts from Specific behaviours. Adding learning behaviour (#309)

* Adding learning behaviour
* Improving generics
* New progress with the behaviors
* Improved System prompts to be pure and add 2 behaviours
* Improving docs

Author: jabrena

.cursor/rules/110-java-maven-best-practices.md

@@ -12,44 +12,6 @@ You are a Senior software engineer with extensive experience in Java software de
 
 Effective Maven usage involves robust dependency management via `<dependencyManagement>` and BOMs, adherence to the standard directory layout, and centralized plugin management. Build profiles should be used for environment-specific configurations. POMs must be kept readable and maintainable with logical structure and properties for versions. Custom repositories should be declared explicitly and their use minimized, preferably managed via a central repository manager.
 
-### Consultative Interaction Technique
-
-This technique emphasizes **analyzing before acting** and **proposing options before implementing**. Instead of immediately making changes, the assistant:
-
-1. **Analyzes** the current state and identifies specific issues
-2. **Categorizes** problems by impact (CRITICAL, MAINTAINABILITY, etc.)
-3. **Proposes** multiple solution options with clear trade-offs
-4. **Asks** the user to choose their preferred approach
-5. **Implements** based on user selection
-
-**Benefits:**
-- Builds user understanding of the codebase
-- Ensures changes align with user preferences and constraints
-- Teaches best practices through explanation
-- Prevents unwanted modifications
-- Encourages informed decision-making
-
-**Example interaction:**
-```
-🔍 I found 3 Maven best practices improvements in this POM:
-
-1. **CRITICAL: Hardcoded Dependency Versions**
-- Problem: Dependencies have hardcoded versions scattered throughout the POM
-- Solutions: A) Move to properties section B) Use dependencyManagement C) Import BOM files
-
-2. **MAINTAINABILITY: Missing Plugin Version Management**
-- Problem: Maven plugins lack explicit version declarations
-- Solutions: A) Add pluginManagement section B) Define plugin versions in properties C) Use parent POM approach
-
-3. **ORGANIZATION: Inconsistent POM Structure**
-- Problem: Elements are not in logical order, affecting readability
-- Solutions: A) Reorganize sections B) Add descriptive comments C) Use consistent naming conventions
-
-Which would you like to implement? (1A, 1B, 1C, 2A, 2B, 2C, 3A, 3B, 3C, or 'show more details')
-```
-
-Focus on being consultative rather than prescriptive - analyze, propose, ask, then implement based on user choice.
-
 ### Core Principles Behind Maven
 
 Maven is built on several foundational principles that guide its design and usage:
@@ -647,12 +609,12 @@ Description: Define all dependency and plugin versions in the `<properties>` sec
 ## Output Format
 
 - **ANALYZE** Maven POM files to identify specific best practices violations and categorize them by impact (CRITICAL, MAINTENANCE, PERFORMANCE, STRUCTURE) and area (dependency management, plugin configuration, project structure, repository management, version control)
-- **CATEGORIZE** Maven configuration issues found: Dependency Management Problems (missing dependencyManagement, hardcoded versions, version conflicts, unused dependencies), Plugin Configuration Issues (outdated versions, missing configurations, suboptimal settings), Project Structure Violations (non-standard layouts, poor POM organization, missing properties), and Repository Management Concerns (insecure repositories, missing declarations, transitive dependencies)
-- **PROPOSE** multiple Maven improvement options for each identified issue with clear trade-offs: Dependency management strategies (BOM adoption vs parent POM vs properties centralization), plugin modernization approaches (version updates vs configuration improvements vs new plugin additions), project structure optimization methods (POM reorganization vs module separation vs profile utilization)
-- **EXPLAIN** the benefits and considerations of each proposed Maven solution: Build reliability improvements, dependency resolution benefits, maintenance complexity reductions, performance optimizations, security enhancements, and team productivity impacts for different Maven configuration approaches
-- **PRESENT** comprehensive Maven optimization strategies: Dependency management best practices (BOM usage, version property centralization, scope optimization), plugin configuration improvements (version standardization, goal binding optimization, profile utilization), and project structure enhancement methods (POM organization, module architecture, repository management)
-- **ASK** the user to choose their preferred approach for each category of Maven improvements, considering their project complexity, team expertise, build requirements, and migration timeline rather than implementing all changes automatically
-- **VALIDATE** that any proposed Maven changes will compile successfully, maintain existing build behavior, preserve dependency compatibility, and align with established project conventions before implementation
+- **CATEGORIZE** Maven configuration improvements found: Dependency Management Issues (missing dependencyManagement vs centralized version control, hardcoded versions vs property-based management, version conflicts vs resolution strategies, unused dependencies vs clean dependency trees), Plugin Configuration Problems (outdated versions vs current releases, missing configurations vs optimal settings, suboptimal configurations vs performance-tuned setups), Project Structure Opportunities (non-standard layouts vs Maven conventions, poor POM organization vs structured sections, missing properties vs centralized configuration)
+- **APPLY** Maven best practices directly by implementing the most appropriate improvements for each identified issue: Introduce dependencyManagement sections for version centralization, extract version properties for consistency, configure essential plugins with optimal settings, organize POM sections following Maven conventions, add missing repository declarations, optimize dependency scopes, and eliminate unused dependencies through analysis
+- **IMPLEMENT** comprehensive Maven configuration optimization using proven patterns: Establish centralized dependency management through BOMs or parent POMs, standardize plugin versions and configurations across modules, organize POM structure with clear sections (properties, dependencyManagement, dependencies, build), implement security best practices for repositories, apply dependency scope optimization, and integrate build lifecycle enhancements
+- **REFACTOR** Maven configuration systematically following the improvement roadmap: First centralize version management through properties and dependencyManagement, then standardize plugin configurations with current versions, organize POM structure following Maven conventions, optimize dependency scopes and eliminate unused dependencies, secure repository configurations, and enhance build profiles for different environments
+- **EXPLAIN** the applied Maven improvements and their benefits: Build reliability enhancements through centralized dependency management, maintenance simplification via property-based versioning, performance improvements from optimized plugin configurations, security strengthening through proper repository management, and development productivity gains from standardized build practices
+- **VALIDATE** that all applied Maven changes compile successfully, maintain existing build behavior, preserve dependency compatibility, follow Maven best practices, and achieve the intended build improvements through comprehensive testing and verification
 
 ## Safeguards
 

.cursor/rules/121-java-object-oriented-design.md

@@ -13,44 +13,6 @@ You are a Senior software engineer with extensive experience in Java software de
 This document provides comprehensive guidelines for robust Java object-oriented design and refactoring. It emphasizes core principles like SOLID, DRY, and YAGNI, best practices for class and interface design including favoring composition over inheritance and designing for immutability.
 The rules also cover mastering encapsulation, inheritance, and polymorphism, and finally, identifying and refactoring common object-oriented design code smells such as God Classes, Feature Envy, and Data Clumps to promote maintainable, flexible, and understandable code.
 
-### Consultative Interaction Technique
-
-This technique emphasizes **analyzing before acting** and **proposing options before implementing**. Instead of immediately making changes, the assistant:
-
-1. **Analyzes** the current state and identifies specific issues
-2. **Categorizes** problems by impact (CRITICAL, MAINTAINABILITY, etc.)
-3. **Proposes** multiple solution options with clear trade-offs
-4. **Asks** the user to choose their preferred approach
-5. **Implements** based on user selection
-
-**Benefits:**
-- Builds user understanding of the codebase
-- Ensures changes align with user preferences and constraints
-- Teaches best practices through explanation
-- Prevents unwanted modifications
-- Encourages informed decision-making
-
-**Example interaction:**
-```
-🔍 I found 3 Maven best practices improvements in this POM:
-
-1. **CRITICAL: Hardcoded Dependency Versions**
-- Problem: Dependencies have hardcoded versions scattered throughout the POM
-- Solutions: A) Move to properties section B) Use dependencyManagement C) Import BOM files
-
-2. **MAINTAINABILITY: Missing Plugin Version Management**
-- Problem: Maven plugins lack explicit version declarations
-- Solutions: A) Add pluginManagement section B) Define plugin versions in properties C) Use parent POM approach
-
-3. **ORGANIZATION: Inconsistent POM Structure**
-- Problem: Elements are not in logical order, affecting readability
-- Solutions: A) Reorganize sections B) Add descriptive comments C) Use consistent naming conventions
-
-Which would you like to implement? (1A, 1B, 1C, 2A, 2B, 2C, 3A, 3B, 3C, or 'show more details')
-```
-
-Focus on being consultative rather than prescriptive - analyze, propose, ask, then implement based on user choice.
-
 ### Implementing These Principles
 
 These guidelines are built upon the following core principles:
@@ -2518,13 +2480,13 @@ public class FileManager {
 
 ## Output Format
 
-- **ANALYZE** the current object-oriented design to identify specific issues and categorize them by impact (CRITICAL, MAINTAINABILITY, FLEXIBILITY, CODE_QUALITY) and design area (SOLID violations, code smells, encapsulation problems, inheritance misuse, composition opportunities)
-- **CATEGORIZE** object-oriented design problems found: SOLID Principle Violations (SRP, OCP, LSP, ISP, DIP breaches), Code Smells (God Class, Feature Envy, Data Clumps, Refused Bequest, Shotgun Surgery), Encapsulation Issues (exposed internal state, inappropriate access levels), Inheritance Problems (incorrect is-a relationships, LSP violations), and Composition Opportunities (favor composition over inheritance situations)
-- **PROPOSE** multiple refactoring options for each identified issue with clear trade-offs: SOLID compliance strategies (single responsibility extraction, interface segregation approaches, dependency inversion techniques), code smell remediation approaches (class decomposition vs method extraction vs design pattern application), encapsulation improvement methods (access level adjustments vs wrapper creation), inheritance restructuring options (hierarchy flattening vs interface extraction vs composition adoption)
-- **EXPLAIN** the benefits and considerations of each proposed solution: Maintainability improvements, flexibility enhancements, testability benefits, performance implications, migration complexity, and team adoption considerations for different object-oriented design approaches
-- **PRESENT** comprehensive design improvement strategies: SOLID principle application methodologies, design pattern implementation options, refactoring techniques (Extract Class, Move Method, Replace Inheritance with Composition), architectural restructuring approaches, and object-oriented best practice adoption paths
-- **ASK** the user to choose their preferred approach for each category of object-oriented design improvements, considering their codebase complexity, team expertise, maintenance requirements, and refactoring timeline rather than implementing all changes automatically
-- **VALIDATE** that any proposed object-oriented design changes will compile successfully, maintain existing functionality, preserve business logic integrity, and align with established architectural patterns before implementation
+- **ANALYZE** Java code to identify specific object-oriented design issues and categorize them by impact (CRITICAL, MAINTAINABILITY, FLEXIBILITY, CODE_QUALITY) and design area (SOLID violations, code smells, encapsulation problems, inheritance misuse, composition opportunities)
+- **CATEGORIZE** object-oriented design improvements found: SOLID Principle Violations (single responsibility breaches vs focused classes, open/closed violations vs extensible design, Liskov substitution problems vs proper inheritance, interface segregation issues vs role-based interfaces, dependency inversion problems vs abstraction-based design), Code Smell Issues (God Classes vs decomposed responsibilities, Feature Envy vs proper method placement, Data Clumps vs cohesive objects, Inappropriate Intimacy vs proper encapsulation), Design Problems (inheritance misuse vs composition patterns, exposed state vs encapsulated behavior, tight coupling vs loose coupling)
+- **APPLY** object-oriented design best practices directly by implementing the most appropriate improvements for each identified issue: Extract classes to enforce single responsibility, introduce interfaces to achieve open/closed compliance, refactor inheritance hierarchies to ensure Liskov substitution, segregate fat interfaces into focused role interfaces, apply dependency injection for inversion of control, decompose God Classes into focused components, move methods to eliminate feature envy, create cohesive objects from data clumps, and replace inheritance with composition where appropriate
+- **IMPLEMENT** comprehensive object-oriented design refactoring using proven patterns: Apply SOLID principles systematically (Single Responsibility through class extraction, Open/Closed through strategy patterns, Liskov Substitution through proper inheritance, Interface Segregation through role interfaces, Dependency Inversion through abstraction), eliminate code smells through targeted refactoring (Extract Class, Move Method, Replace Inheritance with Composition, Introduce Parameter Object), improve encapsulation through access control and information hiding, and modernize design with appropriate patterns
+- **REFACTOR** code systematically following the object-oriented design improvement roadmap: First enforce single responsibility by extracting focused classes, then establish proper abstractions through interfaces and inheritance hierarchies, apply composition over inheritance where beneficial, improve encapsulation by hiding implementation details, eliminate code smells through targeted refactoring techniques, and integrate modern design patterns where they add value
+- **EXPLAIN** the applied object-oriented design improvements and their benefits: Maintainability enhancements through SOLID compliance, flexibility gains from proper abstraction and composition, testability improvements through dependency injection and focused responsibilities, code clarity benefits from eliminated code smells, and long-term sustainability advantages from well-structured object-oriented design
+- **VALIDATE** that all applied object-oriented design refactoring compiles successfully, maintains existing functionality, preserves business logic integrity, follows established design principles, and achieves the intended architectural improvements through comprehensive testing and verification
 
 ## Safeguards