@mark-gozner/aigile-method 0.4.5

package/core/prompts/file-tree-generator.prompt.md

@@ -0,0 +1,405 @@
+---
+description: 'Comprehensive technology-agnostic prompt for analyzing and documenting project folder structures. Auto-detects project types (.NET, Java, React, Angular, Python, Node.js, Flutter), generates detailed blueprints with visualization options, naming conventions, file placement patterns, and extension templates for maintaining consistent code organization across diverse technology stacks.'
+mode: 'agent'
+---
+
+# Project Folder Structure Blueprint Generator
+
+## Configuration Variables
+
+${PROJECT_TYPE="Auto-detect|.NET|Java|React|Angular|Python|Node.js|Flutter|Other"} 
+<!-- Select primary technology -->
+
+${INCLUDES_MICROSERVICES="Auto-detect|true|false"} 
+<!-- Is this a microservices architecture? -->
+
+${INCLUDES_FRONTEND="Auto-detect|true|false"} 
+<!-- Does project include frontend components? -->
+
+${IS_MONOREPO="Auto-detect|true|false"} 
+<!-- Is this a monorepo with multiple projects? -->
+
+${VISUALIZATION_STYLE="ASCII|Markdown List|Table"} 
+<!-- How to visualize the structure -->
+
+${DEPTH_LEVEL=1-5} 
+<!-- How many levels of folders to document in detail -->
+
+${INCLUDE_FILE_COUNTS=true|false} 
+<!-- Include file count statistics -->
+
+${INCLUDE_GENERATED_FOLDERS=true|false} 
+<!-- Include auto-generated folders -->
+
+${INCLUDE_FILE_PATTERNS=true|false} 
+<!-- Document file naming/location patterns -->
+
+${INCLUDE_TEMPLATES=true|false} 
+<!-- Include file/folder templates for new features -->
+
+## Generated Prompt
+
+"Analyze the project's folder structure and create a comprehensive 'Project_Folders_Structure_Blueprint.md' document that serves as a definitive guide for maintaining consistent code organization. Use the following approach:
+
+### Initial Auto-detection Phase
+
+${PROJECT_TYPE == "Auto-detect" ? 
+"Begin by scanning the folder structure for key files that identify the project type:
+- Look for solution/project files (.sln, .csproj, .fsproj, .vbproj) to identify .NET projects
+- Check for build files (pom.xml, build.gradle, settings.gradle) for Java projects
+- Identify package.json with dependencies for JavaScript/TypeScript projects
+- Look for specific framework files (angular.json, react-scripts entries, next.config.js)
+- Check for Python project identifiers (requirements.txt, setup.py, pyproject.toml)
+- Examine mobile app identifiers (pubspec.yaml, android/ios folders)
+- Note all technology signatures found and their versions" : 
+"Focus analysis on ${PROJECT_TYPE} project structure"}
+
+${IS_MONOREPO == "Auto-detect" ? 
+"Determine if this is a monorepo by looking for:
+- Multiple distinct projects with their own configuration files
+- Workspace configuration files (lerna.json, nx.json, turborepo.json, etc.)
+- Cross-project references and shared dependency patterns
+- Root-level orchestration scripts and configuration" : ""}
+
+${INCLUDES_MICROSERVICES == "Auto-detect" ? 
+"Check for microservices architecture indicators:
+- Multiple service directories with similar/repeated structures
+- Service-specific Dockerfiles or deployment configurations
+- Inter-service communication patterns (APIs, message brokers)
+- Service registry or discovery configuration
+- API gateway configuration files
+- Shared libraries or utilities across services" : ""}
+
+${INCLUDES_FRONTEND == "Auto-detect" ? 
+"Identify frontend components by looking for:
+- Web asset directories (wwwroot, public, dist, static)
+- UI framework files (components, modules, pages)
+- Frontend build configuration (webpack, vite, rollup, etc.)
+- Style sheet organization (CSS, SCSS, styled-components)
+- Static asset organization (images, fonts, icons)" : ""}
+
+### 1. Structural Overview
+
+Provide a high-level overview of the ${PROJECT_TYPE == "Auto-detect" ? "detected project type(s)" : PROJECT_TYPE} project's organization principles and folder structure:
+
+- Document the overall architectural approach reflected in the folder structure
+- Identify the main organizational principles (by feature, by layer, by domain, etc.)
+- Note any structural patterns that repeat throughout the codebase
+- Document the rationale behind the structure where it can be inferred
+
+${IS_MONOREPO == "Auto-detect" ? 
+"If detected as a monorepo, explain how the monorepo is organized and the relationship between projects." : 
+IS_MONOREPO ? "Explain how the monorepo is organized and the relationship between projects." : ""}
+
+${INCLUDES_MICROSERVICES == "Auto-detect" ? 
+"If microservices are detected, describe how they are structured and organized." : 
+INCLUDES_MICROSERVICES ? "Describe how the microservices are structured and organized." : ""}
+
+### 2. Directory Visualization
+
+${VISUALIZATION_STYLE == "ASCII" ? 
+"Create an ASCII tree representation of the folder hierarchy to depth level ${DEPTH_LEVEL}." : ""}
+
+${VISUALIZATION_STYLE == "Markdown List" ? 
+"Use nested markdown lists to represent the folder hierarchy to depth level ${DEPTH_LEVEL}." : ""}
+
+${VISUALIZATION_STYLE == "Table" ? 
+"Create a table with columns for Path, Purpose, Content Types, and Conventions." : ""}
+
+${INCLUDE_GENERATED_FOLDERS ? 
+"Include all folders including generated ones." : 
+"Exclude auto-generated folders like bin/, obj/, node_modules/, etc."}
+
+### 3. Key Directory Analysis
+
+Document each significant directory's purpose, contents, and patterns:
+
+${PROJECT_TYPE == "Auto-detect" ? 
+"For each detected technology, analyze directory structures based on observed usage patterns:" : ""}
+
+${(PROJECT_TYPE == ".NET" || PROJECT_TYPE == "Auto-detect") ? 
+"#### .NET Project Structure (if detected)
+
+- **Solution Organization**: 
+  - How projects are grouped and related
+  - Solution folder organization patterns
+  - Multi-targeting project patterns
+
+- **Project Organization**:
+  - Internal folder structure patterns
+  - Source code organization approach
+  - Resource organization
+  - Project dependencies and references
+
+- **Domain/Feature Organization**:
+  - How business domains or features are separated
+  - Domain boundary enforcement patterns
+
+- **Layer Organization**:
+  - Separation of concerns (Controllers, Services, Repositories, etc.)
+  - Layer interaction and dependency patterns
+
+- **Configuration Management**:
+  - Configuration file locations and purposes
+  - Environment-specific configurations
+  - Secret management approach
+
+- **Test Project Organization**:
+  - Test project structure and naming
+  - Test categories and organization
+  - Test data and mock locations" : ""}
+
+${(PROJECT_TYPE == "React" || PROJECT_TYPE == "Angular" || PROJECT_TYPE == "Auto-detect") ? 
+"#### UI Project Structure (if detected)
+
+- **Component Organization**:
+  - Component folder structure patterns
+  - Grouping strategies (by feature, type, etc.)
+  - Shared vs. feature-specific components
+
+- **State Management**:
+  - State-related file organization
+  - Store structure for global state
+  - Local state management patterns
+
+- **Routing Organization**:
+  - Route definition locations
+  - Page/view component organization
+  - Route parameter handling
+
+- **API Integration**:
+  - API client organization
+  - Service layer structure
+  - Data fetching patterns
+
+- **Asset Management**:
+  - Static resource organization
+  - Image/media file structure
+  - Font and icon organization
+  
+- **Style Organization**:
+  - CSS/SCSS file structure
+  - Theme organization
+  - Style module patterns" : ""}
+
+### 4. File Placement Patterns
+
+${INCLUDE_FILE_PATTERNS ? 
+"Document the patterns that determine where different types of files should be placed:
+
+- **Configuration Files**:
+  - Locations for different types of configuration
+  - Environment-specific configuration patterns
+  
+- **Model/Entity Definitions**:
+  - Where domain models are defined
+  - Data transfer object (DTO) locations
+  - Schema definition locations
+  
+- **Business Logic**:
+  - Service implementation locations
+  - Business rule organization
+  - Utility and helper function placement
+  
+- **Interface Definitions**:
+  - Where interfaces and abstractions are defined
+  - How interfaces are grouped and organized
+  
+- **Test Files**:
+  - Unit test location patterns
+  - Integration test placement
+  - Test utility and mock locations
+  
+- **Documentation Files**:
+  - API documentation placement
+  - Internal documentation organization
+  - README file distribution" : 
+"Document where key file types are located in the project."}
+
+### 5. Naming and Organization Conventions
+Document the naming and organizational conventions observed across the project:
+
+- **File Naming Patterns**:
+  - Case conventions (PascalCase, camelCase, kebab-case)
+  - Prefix and suffix patterns
+  - Type indicators in filenames
+  
+- **Folder Naming Patterns**:
+  - Naming conventions for different folder types
+  - Hierarchical naming patterns
+  - Grouping and categorization conventions
+  
+- **Namespace/Module Patterns**:
+  - How namespaces/modules map to folder structure
+  - Import/using statement organization
+  - Internal vs. public API separation
+
+- **Organizational Patterns**:
+  - Code co-location strategies
+  - Feature encapsulation approaches
+  - Cross-cutting concern organization
+
+### 6. Navigation and Development Workflow
+Provide guidance for navigating and working with the codebase structure:
+
+- **Entry Points**:
+  - Main application entry points
+  - Key configuration starting points
+  - Initial files for understanding the project
+
+- **Common Development Tasks**:
+  - Where to add new features
+  - How to extend existing functionality
+  - Where to place new tests
+  - Configuration modification locations
+  
+- **Dependency Patterns**:
+  - How dependencies flow between folders
+  - Import/reference patterns
+  - Dependency injection registration locations
+
+${INCLUDE_FILE_COUNTS ? 
+"- **Content Statistics**:
+  - Files per directory analysis
+  - Code distribution metrics
+  - Complexity concentration areas" : ""}
+
+### 7. Build and Output Organization
+Document the build process and output organization:
+
+- **Build Configuration**:
+  - Build script locations and purposes
+  - Build pipeline organization
+  - Build task definitions
+  
+- **Output Structure**:
+  - Compiled/built output locations
+  - Output organization patterns
+  - Distribution package structure
+  
+- **Environment-Specific Builds**:
+  - Development vs. production differences
+  - Environment configuration strategies
+  - Build variant organization
+
+### 8. Technology-Specific Organization
+
+${(PROJECT_TYPE == ".NET" || PROJECT_TYPE == "Auto-detect") ? 
+"#### .NET-Specific Structure Patterns (if detected)
+
+- **Project File Organization**:
+  - Project file structure and patterns
+  - Target framework configuration
+  - Property group organization
+  - Item group patterns
+  
+- **Assembly Organization**:
+  - Assembly naming patterns
+  - Multi-assembly architecture
+  - Assembly reference patterns
+  
+- **Resource Organization**:
+  - Embedded resource patterns
+  - Localization file structure
+  - Static web asset organization
+  
+- **Package Management**:
+  - NuGet configuration locations
+  - Package reference organization
+  - Package version management" : ""}
+
+${(PROJECT_TYPE == "Java" || PROJECT_TYPE == "Auto-detect") ? 
+"#### Java-Specific Structure Patterns (if detected)
+
+- **Package Hierarchy**:
+  - Package naming and nesting conventions
+  - Domain vs. technical packages
+  - Visibility and access patterns
+  
+- **Build Tool Organization**:
+  - Maven/Gradle structure patterns
+  - Module organization
+  - Plugin configuration patterns
+  
+- **Resource Organization**:
+  - Resource folder structures
+  - Environment-specific resources
+  - Properties file organization" : ""}
+
+${(PROJECT_TYPE == "Node.js" || PROJECT_TYPE == "Auto-detect") ? 
+"#### Node.js-Specific Structure Patterns (if detected)
+
+- **Module Organization**:
+  - CommonJS vs. ESM organization
+  - Internal module patterns
+  - Third-party dependency management
+  
+- **Script Organization**:
+  - npm/yarn script definition patterns
+  - Utility script locations
+  - Development tool scripts
+  
+- **Configuration Management**:
+  - Configuration file locations
+  - Environment variable management
+  - Secret management approaches" : ""}
+
+### 9. Extension and Evolution
+Document how the project structure is designed to be extended:
+
+- **Extension Points**:
+  - How to add new modules/features while maintaining conventions
+  - Plugin/extension folder patterns
+  - Customization directory structures
+  
+- **Scalability Patterns**:
+  - How the structure scales for larger features
+  - Approach for breaking down large modules
+  - Code splitting strategies
+  
+- **Refactoring Patterns**:
+  - Common refactoring approaches observed
+  - How structural changes are managed
+  - Incremental reorganization patterns
+
+${INCLUDE_TEMPLATES ? 
+"### 10. Structure Templates
+
+Provide templates for creating new components that follow project conventions:
+
+- **New Feature Template**:
+  - Folder structure for adding a complete feature
+  - Required file types and their locations
+  - Naming patterns to follow
+  
+- **New Component Template**:
+  - Directory structure for a typical component
+  - Essential files to include
+  - Integration points with existing structure
+  
+- **New Service Template**:
+  - Structure for adding a new service
+  - Interface and implementation placement
+  - Configuration and registration patterns
+  
+- **New Test Structure**:
+  - Folder structure for test projects/files
+  - Test file organization templates
+  - Test resource organization" : ""}
+
+### ${INCLUDE_TEMPLATES ? "11" : "10"}. Structure Enforcement
+
+Document how the project structure is maintained and enforced:
+
+- **Structure Validation**:
+  - Tools/scripts that enforce structure
+  - Build checks for structural compliance
+  - Linting rules related to structure
+  
+- **Documentation Practices**:
+  - How structural changes are documented
+  - Where architectural decisions are recorded
+  - Structure evolution history
+
+Include a section at the end about maintaining this blueprint and when it was last updated.
+"

package/core/prompts/generate-unit-tests.prompt.md

@@ -0,0 +1,291 @@
+---
+description: 'Comprehensive technology-agnostic prompt for unit-test generation. Auto-detects project types (.NET, Java, React, Angular, Python, Node.js, Flutter), generates detailed unit tests for given code snippets / classs.'
+mode: 'agent'
+---
+
+You are an expert unit test generator with deep knowledge of testing frameworks and best practices across multiple programming languages (Java, C#, Python, JavaScript, TypeScript, Go, etc.).
+
+Your task is to generate comprehensive, production-ready unit tests for a given class or function, following language-specific best practices and testing conventions.
+
+# Steps
+
+1. **Receive and Validate Input**: Request the class/function code if not provided. Confirm you have the complete, compilable source code.
+
+2. **Identify Technology Stack**: Analyze the provided code to determine:
+   - Programming language and version
+   - Testing framework (JUnit 5, NUnit, pytest, Jest, etc.)
+   - Dependencies and external libraries used
+   - Code structure (methods, return types, parameters, dependencies)
+
+3. **Analyze Happy Path Scenarios**: Identify the primary, successful execution paths:
+   - Main functionality of each method
+   - Expected inputs that follow the "happy path"
+   - Expected outputs for each happy path scenario
+   - Document 2-4 happy path test cases per method
+
+4. **Identify Edge Cases and Failure Scenarios**: Determine boundary conditions, exceptions, and error handling:
+   - Null/empty inputs (if applicable)
+   - Boundary values (min/max, zero, negative numbers)
+   - Invalid inputs and expected exceptions
+   - State transitions and dependencies
+   - Timeout scenarios (if applicable)
+   - Document 3-5 edge cases per method
+
+5. **Generate Test Class**: Create a fully implemented, compilable test class that includes:
+   - Proper imports and setup for the identified testing framework
+   - Any necessary mocks, stubs, or test fixtures
+   - All test methods from both happy path and edge cases
+   - Proper teardown/cleanup if needed
+
+6. **Format Each Test Method**:
+   - Use a descriptive, suggestive test name following language conventions (e.g., `testMethodName_Scenario_ExpectedResult` for Java, `MethodName_Scenario_ExpectedResult` for C#)
+   - Add a concise JavaDoc/XML Doc comment (2-3 lines) explaining what the test validates
+   - Use clear Arrange-Act-Assert structure
+   - Include meaningful assertions with descriptive messages
+
+7. **Generate Summary**: After all tests, provide a structured summary listing:
+   - Total number of tests generated
+   - Happy path scenarios covered (with brief descriptions)
+   - Edge cases covered (with brief descriptions)
+   - Testing framework and any special configurations used
+
+# Output Format
+
+Output the complete test class code in the appropriate language syntax, ready to compile and run. Format as follows:
+
+1. **Test Class Code**: Present the full, compilable test class with all necessary imports and annotations
+2. **Summary Section**: After the code block, provide a summary table or list with:
+   - Column headers: Test Name | Scenario | Category (Happy Path/Edge Case)
+   - Include all tests in the list
+   - At the end, note any assumptions or limitations
+
+Use markdown code blocks with the appropriate language identifier (java, csharp, python, etc.). Maintain proper indentation and formatting.
+
+# Examples
+
+**Example 1: Java Class (Happy Path + Edge Cases)**
+
+Input:
+```java
+public class Calculator {
+    public int add(int a, int b) {
+        return a + b;
+    }
+    
+    public int divide(int a, int b) {
+        if (b == 0) throw new IllegalArgumentException("Divisor cannot be zero");
+        return a / b;
+    }
+}
+```
+
+Output (Test Class):
+```java
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.DisplayName;
+import static org.junit.jupiter.api.Assertions.*;
+
+@DisplayName("Calculator Tests")
+public class CalculatorTest {
+    
+    private Calculator calculator = new Calculator();
+    
+    // ===== ADD METHOD TESTS =====
+    
+    /**
+     * Validates that add() correctly sums two positive integers.
+     * Happy path: 5 + 3 should equal 8.
+     */
+    @Test
+    @DisplayName("add() should return sum of two positive numbers")
+    public void testAdd_TwoPositiveNumbers_ReturnSum() {
+        int result = calculator.add(5, 3);
+        assertEquals(8, result, "5 + 3 should equal 8");
+    }
+    
+    /**
+     * Validates that add() correctly handles negative numbers.
+     * Happy path: -5 + 3 should equal -2.
+     */
+    @Test
+    @DisplayName("add() should handle negative numbers correctly")
+    public void testAdd_WithNegativeNumbers_ReturnSum() {
+        int result = calculator.add(-5, 3);
+        assertEquals(-2, result, "-5 + 3 should equal -2");
+    }
+    
+    /**
+     * Edge case: add() with zero values.
+     * Validates that zero is treated as a valid addend.
+     */
+    @Test
+    @DisplayName("add() should handle zero as an operand")
+    public void testAdd_WithZero_ReturnNonZeroOperand() {
+        int result = calculator.add(5, 0);
+        assertEquals(5, result, "5 + 0 should equal 5");
+    }
+    
+    /**
+     * Edge case: add() with both operands as zero.
+     * Validates that 0 + 0 equals 0.
+     */
+    @Test
+    @DisplayName("add() should return zero when adding two zeros")
+    public void testAdd_BothZero_ReturnZero() {
+        int result = calculator.add(0, 0);
+        assertEquals(0, result, "0 + 0 should equal 0");
+    }
+    
+    /**
+     * Validates that divide() correctly divides two positive integers.
+     * Happy path: 10 / 2 should equal 5.
+     */
+    @Test
+    @DisplayName("divide() should return quotient of two positive numbers")
+    public void testDivide_TwoPositiveNumbers_ReturnQuotient() {
+        int result = calculator.divide(10, 2);
+        assertEquals(5, result, "10 / 2 should equal 5");
+    }
+    
+    /**
+     * Edge case: divide() with dividend as zero.
+     * Validates that 0 / n equals 0.
+     */
+    @Test
+    @DisplayName("divide() should return zero when dividend is zero")
+    public void testDivide_DividendIsZero_ReturnZero() {
+        int result = calculator.divide(0, 5);
+        assertEquals(0, result, "0 / 5 should equal 0");
+    }
+    
+    /**
+     * Edge case: divide() by zero throws exception.
+     * Validates that IllegalArgumentException is thrown when divisor is zero.
+     */
+    @Test
+    @DisplayName("divide() should throw IllegalArgumentException when divisor is zero")
+    public void testDivide_DivisorIsZero_ThrowIllegalArgumentException() {
+        assertThrows(IllegalArgumentException.class, () -> {
+            calculator.divide(10, 0);
+        }, "Dividing by zero should throw IllegalArgumentException");
+    }
+}
+```
+
+Summary:
+
+| Test Name | Scenario | Category |
+|-----------|----------|----------|
+| testAdd_TwoPositiveNumbers_ReturnSum | Add two positive integers | Happy Path |
+| testAdd_WithNegativeNumbers_ReturnSum | Add positive and negative integers | Happy Path |
+| testAdd_WithZero_ReturnNonZeroOperand | Add with one zero operand | Edge Case |
+| testAdd_BothZero_ReturnZero | Add two zeros | Edge Case |
+| testDivide_TwoPositiveNumbers_ReturnQuotient | Divide two positive integers | Happy Path |
+| testDivide_DividendIsZero_ReturnZero | Divide with zero dividend | Edge Case |
+| testDivide_DivisorIsZero_ThrowIllegalArgumentException | Divide by zero (exception) | Edge Case |
+
+**Total Tests**: 7 (3 happy path, 4 edge cases)
+**Framework**: JUnit 5 with Assertions
+**Assumptions**: Calculator class is instantiable with no-arg constructor.
+
+---
+
+**Example 2: C# Class (Happy Path + Edge Cases)**
+
+Input:
+```csharp
+public class StringValidator {
+    public bool IsValidEmail(string email) {
+        if (string.IsNullOrWhiteSpace(email)) return false;
+        return email.Contains("@") && email.Contains(".");
+    }
+}
+```
+
+Output (Test Class):
+```csharp
+using Xunit;
+
+public class StringValidatorTests {
+    
+    private readonly StringValidator _validator = new StringValidator();
+    
+    // ===== ISVALIDEMAIL METHOD TESTS =====
+    
+    /// <summary>
+    /// Validates that IsValidEmail() returns true for a properly formatted email.
+    /// Happy path: valid email address with domain extension.
+    /// </summary>
+    [Fact]
+    public void IsValidEmail_ValidEmailAddress_ReturnsTrue() {
+        bool result = _validator.IsValidEmail("user@example.com");
+        Assert.True(result, "Valid email 'user@example.com' should return true");
+    }
+    
+    /// <summary>
+    /// Validates that IsValidEmail() returns false for email without domain extension.
+    /// Edge case: missing dot in domain.
+    /// </summary>
+    [Fact]
+    public void IsValidEmail_EmailWithoutDomainExtension_ReturnsFalse() {
+        bool result = _validator.IsValidEmail("user@example");
+        Assert.False(result, "Email without domain extension should return false");
+    }
+    
+    /// <summary>
+    /// Edge case: IsValidEmail() with null input.
+    /// Validates that null returns false without throwing an exception.
+    /// </summary>
+    [Fact]
+    public void IsValidEmail_NullInput_ReturnsFalse() {
+        bool result = _validator.IsValidEmail(null);
+        Assert.False(result, "Null input should return false");
+    }
+    
+    /// <summary>
+    /// Edge case: IsValidEmail() with empty string.
+    /// Validates that empty string returns false.
+    /// </summary>
+    [Fact]
+    public void IsValidEmail_EmptyString_ReturnsFalse() {
+        bool result = _validator.IsValidEmail("");
+        Assert.False(result, "Empty string should return false");
+    }
+    
+    /// <summary>
+    /// Edge case: IsValidEmail() with whitespace-only string.
+    /// Validates that whitespace-only input returns false.
+    /// </summary>
+    [Fact]
+    public void IsValidEmail_WhitespaceOnlyString_ReturnsFalse() {
+        bool result = _validator.IsValidEmail("   ");
+        Assert.False(result, "Whitespace-only string should return false");
+    }
+}
+```
+
+Summary:
+
+| Test Name | Scenario | Category |
+|-----------|----------|----------|
+| IsValidEmail_ValidEmailAddress_ReturnsTrue | Valid email format with @ and . | Happy Path |
+| IsValidEmail_EmailWithoutDomainExtension_ReturnsFalse | Missing domain extension (.) | Edge Case |
+| IsValidEmail_NullInput_ReturnsFalse | Null input handling | Edge Case |
+| IsValidEmail_EmptyString_ReturnsFalse | Empty string input | Edge Case |
+| IsValidEmail_WhitespaceOnlyString_ReturnsFalse | Whitespace-only string | Edge Case |
+
+**Total Tests**: 5 (1 happy path, 4 edge cases)
+**Framework**: xUnit
+**Assumptions**: StringValidator class uses only public methods with no external dependencies.
+
+---
+
+# Notes
+
+- **Framework Selection**: Automatically detect and use the most appropriate testing framework for the identified language (JUnit 5 for Java, xUnit/NUnit for C#, pytest for Python, etc.)
+- **Compilation Readiness**: Ensure all generated test code is syntactically correct and ready to compile without modifications
+- **Mocking**: If the class has external dependencies, include appropriate mocking setup (Mockito for Java, Moq for C#, etc.)
+- **Documentation**: Every test must have a concise but meaningful comment explaining its purpose
+- **Test Naming**: Follow language-specific conventions (snake_case for Java/Python, PascalCase for C#)
+- **Edge Cases Priority**: Prioritize common edge cases (null, empty, zero, negative, max/min values, invalid states) before exotic scenarios
+- **If Code is Not Provided**: Ask the user to paste the class/function code before proceeding, and confirm it is the complete source that should be tested