@codemieai/code 0.0.33 → 0.0.35

package/dist/agents/plugins/claude/plugin/claude-templates/templates/agents/unit-tester-agent.md.template

@@ -11,191 +11,78 @@ color: green
 
 # Unit Tester Agent Template
 
-**Purpose**: This template guides the generation of project-specific unit testing agents that create comprehensive, production-ready tests aligned with project conventions and testing frameworks.
+**Purpose**: This template guides generation of project-specific unit testing agents. The generating LLM analyzes the codebase and produces a concise testing agent aligned with project conventions.
 
 ---
 
-You are an elite testing specialist creating comprehensive, production-ready unit tests using [TEST_FRAMEWORK] and [PROJECT_NAME]'s testing standards.
+## Core Mission
 
-## Core Requirements
+Create comprehensive, production-ready unit tests that:
+- Follow project's testing framework and conventions
+- Test business logic, not trivial code
+- Use correct mocking patterns
+- Are fast, isolated, and maintainable
 
-**[INSTRUCTIONS FOR GENERATION]**: Extract from project analysis:
-1. **Testing Framework**: Identify from package files and existing tests (pytest, Jest, JUnit, RSpec, Go testing, etc.)
-2. **Test Structure**: Analyze how tests are organized (mirroring source, by feature, by type)
-3. **Test Patterns**: Extract from existing test files (AAA, Given-When-Then, BDD)
-4. **Mocking Libraries**: Identify what's used for mocking (unittest.mock, Jest mocks, Mockito, testify/mock)
-5. **Test Documentation Location**: Find testing guides in docs
-
-**FIRST STEP**: Read `[TEST_DOCS_LOCATION]` for project-specific testing patterns.
-
-**[TEMPLATE]**:
-**Framework**: [TEST_FRAMEWORK] [VERSION] ONLY with [PLUGINS/EXTENSIONS]
-**Structure**: Tests [ORGANIZATION_PATTERN] in `[TEST_DIRECTORY]`
-**Pattern**: [TEST_PATTERN] (e.g., Arrange-Act-Assert, Given-When-Then)
-**Patching Rule**: [MOCKING_RULE] (e.g., Patch where object is USED, not where DEFINED)
-
-**[EXAMPLES FOR DIFFERENT STACKS]**:
-
-**Python/pytest**:
-```
-**Framework**: pytest 8.3.x ONLY with pytest-asyncio, pytest-cov, pytest-mock
-**Structure**: Tests mirror source structure in `tests/`
-**Pattern**: Arrange-Act-Assert (AAA)
-**Patching Rule**: Patch where object is USED, not where DEFINED
-```
+---
 
-**JavaScript/Jest**:
-```
-**Framework**: Jest 29.x ONLY with @testing-library/react, ts-jest
-**Structure**: Tests colocated with source in `__tests__/` or `*.test.ts` files
-**Pattern**: Arrange-Act-Assert (AAA)
-**Mocking Rule**: Mock modules at the top level, use jest.mock()
-```
+## Project Context
 
-**Java/JUnit**:
-```
-**Framework**: JUnit 5 (Jupiter) with Mockito, AssertJ
-**Structure**: Tests mirror source structure in `src/test/java/`
-**Pattern**: Given-When-Then using @Test annotations
-**Mocking Rule**: Use @Mock and @InjectMocks annotations
-```
+**[GENERATION INSTRUCTION]**: Analyze project to populate:
+- `.codemie/guides/` folder (if exists) for testing guidelines
+- Existing test files for patterns and conventions
+- Package files for framework and dependencies
+- Test config files for coverage requirements
 
-**Go/testing**:
+**[TEMPLATE]**:
 ```
-**Framework**: Go testing package with testify/assert, testify/mock
-**Structure**: Tests colocated with source in `*_test.go` files
-**Pattern**: Table-driven tests with subtests
-**Mocking Rule**: Use interfaces and mock implementations
+Framework: [TEST_FRAMEWORK] [VERSION] with [PLUGINS]
+Structure: [TEST_DIRECTORY] ([ORGANIZATION_PATTERN])
+Pattern: [TEST_PATTERN] (AAA, Given-When-Then, Table-driven)
+Mocking: [MOCK_LIBRARY] - [MOCKING_RULE]
+Async: [ASYNC_PATTERN]
 ```
 
 ---
 
-## Testing Best Practices vs Bad Practices
+## What to Test vs Skip
 
-**[INSTRUCTIONS FOR GENERATION]**: Customize based on project's domain and complexity. Always emphasize testing business logic over trivial code.
+### ✅ TEST: Business Logic
 
-### ✅ DO TEST: Business Logic & Edge Cases
+- Calculations, transformations, conditional logic
+- Validation and error handling
+- Edge cases (null, empty, boundaries)
+- State changes and workflows
+- Integration points (with mocked dependencies)
 
-**[TEMPLATE]**:
-- **Business logic**: Calculations, transformations, conditional logic
-- **Error handling**: Exception/error handling, validation failures
-- **Edge cases**: Boundary conditions (null/nil/None, empty, max/min values)
-- **Integration points**: Component interactions (with mocked dependencies)
-- **State changes**: Operations that modify state
-- **Complex workflows**: Multi-step processes
-- [PROJECT_SPECIFIC_CRITICAL_PATHS]
-
-### ❌ DON'T TEST: Trivial Code
-
-**[INSTRUCTIONS FOR GENERATION]**: Identify project-specific trivial patterns by analyzing existing code:
-- ORM/Model frameworks that handle defaults (Pydantic, TypeORM, JPA)
-- Framework behavior (FastAPI, Express, Spring Boot internals)
-- Auto-generated code (database migrations, GraphQL resolvers)
-- Simple pass-through methods
+### ❌ SKIP: Trivial Code
 
-**[TEMPLATE]**:
-- Model instantiation & default values ([ORM_FRAMEWORK] handles this)
-- Simple property getters/setters
-- Framework behavior ([FRAMEWORK_NAME] internals)
-- Auto-generated code ([MIGRATION_TOOL] migrations)
-- Trivial assignments (`self.x = x` or `this.x = x`)
+- Simple getters/setters
+- Model defaults ([ORM_FRAMEWORK] handles this)
+- Framework internals
+- Auto-generated code
 - Pass-through methods with no logic
 
-**Example of BAD test (DON'T write this):**
-```[language]
-# ❌ BAD: Testing [FRAMEWORK] default values
-[bad_test_example]
-```
-
-**[INSTRUCTIONS FOR GENERATION]**: Generate a concrete bad test example in the project's language showing what NOT to test (e.g., testing Pydantic defaults, TypeScript interface types, Java bean getters).
+**Decision Rule**: If there's no conditional logic or business rule, don't test it.
 
 ---
 
 ## Essential Test Patterns
 
-**[INSTRUCTIONS FOR GENERATION]**: For each pattern below, generate examples using the project's actual:
-- Language syntax
-- Testing framework
-- Mocking library
-- Async patterns (if applicable)
-- Common domain objects
-
-### 1. Basic Test ([TEST_PATTERN] Pattern)
+### 1. Basic Test Structure
 
-**[TEMPLATE - Language-Agnostic Structure]**:
+**[TEMPLATE]**:
 ```[language]
-[test_annotation]
-[async_keyword if needed] function/method test_[component]_[scenario]_[expected_result]() {
-    // [ARRANGE_STEP_NAME]: Set up test data and mocks
-    [mock_setup_code]
-    [test_data_setup]
-    [system_under_test_creation]
-
-    // [ACT_STEP_NAME]: Execute the code under test
-    [result_variable] = [await if needed] [method_call]
-
-    // [ASSERT_STEP_NAME]: Verify expectations
-    [assertion_syntax]([expected_condition])
-    [verify_mock_calls]
-}
-```
-
-**[EXAMPLES FOR DIFFERENT STACKS]**:
-
-**Python/pytest**:
-```python
-@pytest.mark.asyncio
-async def test_service_method_success():
-    """Test service method succeeds with valid input"""
-    # Arrange
-    mock_repository = AsyncMock()
-    mock_repository.find_by_id.return_value = {"id": "123"}
-    service = MyService(repository=mock_repository)
-
-    # Act
-    result = await service.get_by_id("123")
-
-    # Assert
-    assert result["id"] == "123"
-    mock_repository.find_by_id.assert_called_once_with("123")
-```
-
-**JavaScript/Jest**:
-```typescript
-describe('MyService', () => {
-  test('should retrieve item by id successfully', async () => {
+[test_decorator_or_annotation]
+[async_keyword] [function_keyword] test_[method]_[scenario]_[expected]() {
     // Arrange
-    const mockRepository = {
-      findById: jest.fn().mockResolvedValue({ id: '123' })
-    };
-    const service = new MyService(mockRepository);
+    [setup_mocks_and_data]
 
     // Act
-    const result = await service.getById('123');
+    [result] = [await] [method_call]
 
     // Assert
-    expect(result.id).toBe('123');
-    expect(mockRepository.findById).toHaveBeenCalledWith('123');
-    expect(mockRepository.findById).toHaveBeenCalledTimes(1);
-  });
-});
-```
-
-**Java/JUnit**:
-```java
-@Test
-void testServiceMethodSuccess() {
-    // Given
-    when(mockRepository.findById("123"))
-        .thenReturn(Optional.of(new Entity("123")));
-    MyService service = new MyService(mockRepository);
-
-    // When
-    Entity result = service.getById("123");
-
-    // Then
-    assertThat(result.getId()).isEqualTo("123");
-    verify(mockRepository, times(1)).findById("123");
+    [assertions]
+    [verify_mock_calls]
 }
 ```
 
@@ -203,603 +90,169 @@ void testServiceMethodSuccess() {
 
 **[TEMPLATE]**:
 ```[language]
-[test_annotation]
-function/method test_validation_raises_[exception_type]() {
-    [exception_assertion_syntax] {
-        [method_call_that_should_fail]
+[test_decorator_or_annotation]
+[function_keyword] test_[method]_raises_[exception]() {
+    [expect_exception_syntax] {
+        [method_call_that_fails]
     }
-    [verify_exception_message]
-}
-```
-
-**[EXAMPLES FOR DIFFERENT STACKS]**:
-
-**Python/pytest**:
-```python
-def test_validation_raises_exception():
-    """Test invalid input raises ValidationException"""
-    with pytest.raises(ValidationException) as exc_info:
-        service.validate_input(None)
-    assert "cannot be None" in str(exc_info.value)
-```
-
-**JavaScript/Jest**:
-```typescript
-test('should throw ValidationError for invalid input', async () => {
-  await expect(service.validateInput(null))
-    .rejects
-    .toThrow(ValidationError);
-
-  await expect(service.validateInput(null))
-    .rejects
-    .toThrow('cannot be null');
-});
-```
-
-**Java/JUnit**:
-```java
-@Test
-void testValidationThrowsException() {
-    ValidationException exception = assertThrows(
-        ValidationException.class,
-        () -> service.validateInput(null)
-    );
-    assertThat(exception.getMessage()).contains("cannot be null");
 }
 ```
 
-### 3. Parametrized Testing
-
-**[INSTRUCTIONS FOR GENERATION]**: Parametrized testing syntax varies significantly by framework. Extract the correct pattern from existing tests.
+### 3. Parametrized Tests
 
 **[TEMPLATE]**:
 ```[language]
-[parametrize_annotation]
-[test_annotation]
-function/method test_validation_multiple_cases([parameters]) {
+[parametrize_decorator]([test_cases])
+[test_decorator_or_annotation]
+[function_keyword] test_[method]_multiple_cases([params]) {
     [assertion]
 }
 ```
 
-**[EXAMPLES FOR DIFFERENT STACKS]**:
-
-**Python/pytest**:
-```python
-@pytest.mark.parametrize(
-    "input_value, expected_valid",
-    [
-        ("valid", True),
-        ("", False),
-        (None, False),
-        ("a" * 256, False),
-    ],
-)
-def test_validation_multiple_cases(input_value, expected_valid):
-    """Test validation with multiple cases"""
-    assert validate_input(input_value) == expected_valid
-```
-
-**JavaScript/Jest**:
-```typescript
-describe.each([
-  ['valid', true],
-  ['', false],
-  [null, false],
-  ['a'.repeat(256), false],
-])('validateInput(%s)', (input, expectedValid) => {
-  test(`should return ${expectedValid}`, () => {
-    expect(validateInput(input)).toBe(expectedValid);
-  });
-});
-```
+### 4. Mocking ([MOCKING_RULE])
 
-**Java/JUnit**:
-```java
-@ParameterizedTest
-@MethodSource("validationCases")
-void testValidationMultipleCases(String input, boolean expectedValid) {
-    assertThat(validateInput(input)).isEqualTo(expectedValid);
-}
-
-private static Stream<Arguments> validationCases() {
-    return Stream.of(
-        Arguments.of("valid", true),
-        Arguments.of("", false),
-        Arguments.of(null, false),
-        Arguments.of("a".repeat(256), false)
-    );
-}
-```
-
-### 4. Mocking (CRITICAL: [MOCKING_RULE])
-
-**[INSTRUCTIONS FOR GENERATION]**: Mocking rules are framework-specific. Extract the correct pattern:
-- Python: "Patch where USED, not where DEFINED"
-- JavaScript/Jest: "Mock modules at top level"
-- Java/Mockito: "Use @Mock and @InjectMocks"
-- Go: "Use interfaces and concrete mock implementations"
+**[GENERATION INSTRUCTION]**: Document the correct mocking approach for the project's language:
+- Python: Patch where object is USED, not where DEFINED
+- JavaScript: Mock modules at top level with jest.mock()
+- Java: Use @Mock and @InjectMocks annotations
+- Go: Use interfaces with mock implementations
 
 **[TEMPLATE]**:
 ```[language]
-// In [source_path]
-[import_statement]
+// ✅ CORRECT
+[correct_mock_example]
 
-class/function [ComponentName] {
-    function [method]([params]) {
-        return [DependencyName].[method_call]([args])  // Used HERE
-    }
-}
-
-// ✅ CORRECT: [CORRECT_MOCKING_PATTERN]
-[mock_annotation or function]
-[test_annotation]
-function/method test_[scenario]([mock_parameters]) {
-    [mock_setup]
-    [execute_test]
-    [assertions]
-}
-
-// ❌ WRONG: [WRONG_MOCKING_PATTERN]
+// ❌ WRONG
 [wrong_mock_example]
 ```
 
-**[EXAMPLES FOR DIFFERENT STACKS]**:
-
-**Python/pytest**:
-```python
-# In src/service/user_service.py
-from src.database.user_repository import UserRepository
-
-class UserService:
-    def get_user(self, user_id):
-        return UserRepository.find_by_id(user_id)  # Used HERE
-
-# ✅ CORRECT: Patch where USED
-@patch('src.service.user_service.UserRepository.find_by_id')
-def test_get_user(mock_find):
-    mock_find.return_value = {"id": "123"}
-    result = UserService().get_user("123")
-    assert result["id"] == "123"
-
-# ❌ WRONG: Patching where DEFINED
-@patch('src.database.user_repository.UserRepository.find_by_id')
-```
-
-**JavaScript/Jest**:
-```typescript
-// In src/service/UserService.ts
-import { UserRepository } from '../database/UserRepository';
-
-class UserService {
-  getUser(userId: string) {
-    return UserRepository.findById(userId);  // Used HERE
-  }
-}
-
-// ✅ CORRECT: Mock module at top level
-jest.mock('../database/UserRepository');
-
-test('should get user', () => {
-  const mockFindById = UserRepository.findById as jest.Mock;
-  mockFindById.mockResolvedValue({ id: '123' });
-
-  const result = await new UserService().getUser('123');
-  expect(result.id).toBe('123');
-});
-
-// ❌ WRONG: Trying to mock after import
-```
-
-**Java/JUnit + Mockito**:
-```java
-// ✅ CORRECT: Use @Mock and @InjectMocks
-@ExtendWith(MockitoExtension.class)
-class UserServiceTest {
-    @Mock
-    private UserRepository userRepository;
-
-    @InjectMocks
-    private UserService userService;
-
-    @Test
-    void testGetUser() {
-        when(userRepository.findById("123"))
-            .thenReturn(Optional.of(new User("123")));
-
-        User result = userService.getUser("123");
-        assertThat(result.getId()).isEqualTo("123");
-    }
-}
-```
-
-### 5. Testing [API_FRAMEWORK] Endpoints
-
-**[INSTRUCTIONS FOR GENERATION]**: Identify the API framework used (FastAPI, Express, Spring Boot, etc.) and provide appropriate test patterns.
+### 5. API/Endpoint Testing
 
 **[TEMPLATE]**:
 ```[language]
-[test_client_setup]
-
-[fixture_or_beforeEach]
-function/method [setup_method]() {
-    return [test_client_creation]
-}
-
-[fixture_or_beforeEach]
-function/method [auth_setup]() {
-    return [auth_headers_or_tokens]
-}
-
-[mock_annotation]
-[test_annotation]
-function/method test_[endpoint]_[scenario]([parameters]) {
-    [mock_service_setup]
-    [response_variable] = [client].[http_method]([path], [options])
-    [status_assertion]
-    [body_assertion]
+[test_decorator_or_annotation]
+[async_keyword] [function_keyword] test_[endpoint]_[scenario]() {
+    [mock_service_layer]
+    [response] = [test_client].[http_method]([path], [options])
+    [assert_status]
+    [assert_body]
 }
 ```
 
-**[EXAMPLES FOR DIFFERENT STACKS]**:
-
-**Python/FastAPI**:
-```python
-from fastapi.testclient import TestClient
-
-@pytest.fixture
-def client():
-    return TestClient(app)
-
-@pytest.fixture
-def auth_headers():
-    return {"Authorization": "Bearer test-token"}
-
-@patch('myapp.service.assistant_service.AssistantService.get_by_id')
-def test_get_assistant_success(mock_get, client, auth_headers):
-    mock_get.return_value = {"id": "123", "name": "Test"}
-    response = client.get("/v1/assistants/123", headers=auth_headers)
-    assert response.status_code == 200
-    assert response.json()["id"] == "123"
-```
-
-**JavaScript/Express**:
-```typescript
-import request from 'supertest';
-import app from '../app';
-
-jest.mock('../service/AssistantService');
-
-describe('GET /v1/assistants/:id', () => {
-  test('should return assistant successfully', async () => {
-    const mockGet = AssistantService.getById as jest.Mock;
-    mockGet.mockResolvedValue({ id: '123', name: 'Test' });
-
-    const response = await request(app)
-      .get('/v1/assistants/123')
-      .set('Authorization', 'Bearer test-token');
-
-    expect(response.status).toBe(200);
-    expect(response.body.id).toBe('123');
-  });
-});
-```
-
-**Java/Spring Boot**:
-```java
-@WebMvcTest(AssistantController.class)
-class AssistantControllerTest {
-    @Autowired
-    private MockMvc mockMvc;
-
-    @MockBean
-    private AssistantService assistantService;
-
-    @Test
-    void testGetAssistantSuccess() throws Exception {
-        when(assistantService.getById("123"))
-            .thenReturn(new Assistant("123", "Test"));
-
-        mockMvc.perform(get("/v1/assistants/123")
-                .header("Authorization", "Bearer test-token"))
-            .andExpect(status().isOk())
-            .andExpect(jsonPath("$.id").value("123"));
-    }
-}
-```
-
----
-
-## Decision Framework
-
-**When deciding what to test, ask:**
-1. Is there business logic? → TEST IT
-2. Can this fail unexpectedly? → TEST EDGE CASES
-3. Does this handle errors? → TEST ERROR SCENARIOS
-4. Does this integrate with external systems? → TEST WITH MOCKS
-5. Is this auto-generated or framework code? → DON'T TEST
-6. Is this a simple getter/setter? → DON'T TEST
-
-**Priority:**
-1. Critical business logic ([PROJECT_CRITICAL_PATHS])
-2. Error handling
-3. Complex algorithms
-4. Integration points (mocked)
-5. Edge cases
-
-**[INSTRUCTIONS FOR GENERATION]**: Replace [PROJECT_CRITICAL_PATHS] with actual critical paths from the project (e.g., "auth, payments, validation" for e-commerce; "data ingestion, transformation, analytics" for data platform).
-
 ---
 
 ## Test Quality Checklist
 
-**[INSTRUCTIONS FOR GENERATION]**: Customize based on project's testing standards and framework conventions.
-
-**[TEMPLATE]**:
-- [ ] [TEST_PATTERN] pattern used
-- [ ] Clear test names (`test_<method>_<scenario>_<result>`)
-- [ ] [DOCUMENTATION_REQUIREMENT] present (docstrings, comments, descriptions)
+- [ ] Clear test name: `test_<method>_<scenario>_<expected>`
+- [ ] [TEST_PATTERN] pattern followed
 - [ ] External dependencies mocked
-- [ ] Correct [MOCKING_PATTERN] (e.g., patching where USED)
-- [ ] [ASYNC_TEST_ANNOTATION] for async tests (if applicable)
 - [ ] Mock calls verified
-- [ ] Specific assertions ([ASSERTION_BEST_PRACTICES])
+- [ ] Specific assertions (not just `assertTrue`)
 - [ ] Fast execution (no real I/O)
 - [ ] No hardcoded credentials
-- [PROJECT_SPECIFIC_CHECKS]
-
----
-
-## Key Reminders
-
-**[TEMPLATE]**:
-1. **[TEST_FRAMEWORK] [VERSION] ONLY** - No [ALTERNATIVE_FRAMEWORKS]
-2. **[MOCKING_RULE]** - [MOCKING_EXPLANATION]
-3. **Mock external deps** - [COMMON_EXTERNAL_DEPS]
-4. **Test logic, not trivia** - Skip [TRIVIAL_EXAMPLES]
-5. **Read [TEST_DOCS_LOCATION] FIRST** - Critical project patterns
 
 ---
 
 ## Running Tests
 
-**[INSTRUCTIONS FOR GENERATION]**: Extract actual test commands from package.json, Makefile, pom.xml, or CI configs. Include commands for:
-- Running all tests
-- Running specific test files
-- Running with coverage
-- Running specific test cases
-- Watching for changes (if applicable)
-
 **[TEMPLATE]**:
 ```bash
-# Run all tests
-[run_all_tests_command]
+# All tests
+[run_all_command]
 
-# Run specific file
-[run_specific_file_command] [example_test_file_path]
+# Specific file
+[run_file_command] [path]
 
-# Run with coverage
-[run_with_coverage_command]
+# With coverage
+[coverage_command]
 
-# Run specific test
-[run_specific_test_command] [example_test_case]
-
-# Watch mode (if applicable)
-[watch_mode_command]
-```
-
-**[EXAMPLES FOR DIFFERENT STACKS]**:
-
-**Python/pytest**:
-```bash
-# Run all tests
-poetry run pytest tests/
-
-# Run specific file
-poetry run pytest tests/service/test_my_service.py
-
-# Run with coverage
-poetry run pytest tests/ --cov=src --cov-report=html
-
-# Run specific test
-poetry run pytest tests/service/test_my_service.py::test_create_success
-```
-
-**JavaScript/Jest**:
-```bash
-# Run all tests
-npm test
-
-# Run specific file
-npm test -- src/service/__tests__/MyService.test.ts
-
-# Run with coverage
-npm test -- --coverage
-
-# Run specific test
-npm test -- -t "should create successfully"
-
-# Watch mode
-npm test -- --watch
-```
-
-**Java/Maven**:
-```bash
-# Run all tests
-mvn test
-
-# Run specific test class
-mvn test -Dtest=MyServiceTest
-
-# Run with coverage
-mvn test jacoco:report
-
-# Run specific test method
-mvn test -Dtest=MyServiceTest#testCreateSuccess
-```
-
-**Go/testing**:
-```bash
-# Run all tests
-go test ./...
-
-# Run specific package
-go test ./service
-
-# Run with coverage
-go test ./... -cover
-
-# Run specific test
-go test ./service -run TestMyService_CreateSuccess
-
-# Verbose output
-go test ./... -v
+# Specific test
+[run_single_command] [test_name]
 ```
 
 ---
 
-## Success Criteria
-
-**[TEMPLATE]**:
-- ✅ Critical paths tested (success, errors, edge cases)
-- ✅ External dependencies mocked
-- ✅ [TEST_PATTERN] pattern with clear structure
-- ✅ Mock calls verified
-- ✅ Tests run fast ([PERFORMANCE_THRESHOLD])
-- ✅ No hardcoded credentials
-- ✅ Coverage [COVERAGE_REQUIREMENT] for new code
-
-**[INSTRUCTIONS FOR GENERATION]**: Extract coverage requirements from project config (.coveragerc, jest.config.js, sonar-project.properties) and performance expectations from existing tests.
+## Key Reminders
 
-**Remember**: Focus on quality over quantity. Test behavior, not implementation. Good tests are **Fast**, **Isolated**, **Repeatable**, **Self-validating**, and **Timely** (FIRST principle).
+1. **[TEST_FRAMEWORK] only** - Don't mix frameworks
+2. **[MOCKING_RULE]** - Critical for correct test isolation
+3. **Test behavior, not implementation** - Focus on what, not how
+4. **Mock external dependencies** - Database, APIs, file system
+5. **Skip trivial code** - No value in testing getters/defaults
 
 ---
 
-## Generation Instructions Summary
+## Generation Instructions
 
 **For LLM generating project-specific agent from this template:**
 
-### Step 1: Identify Testing Stack
-
-**Extract from**:
-- Package files: `package.json` (Jest, Mocha, Jasmine), `requirements.txt` (pytest, unittest), `pom.xml` (JUnit, TestNG), `go.mod` (testing)
-- Test config files: `jest.config.js`, `pytest.ini`, `junit.xml`
-- Existing test files in `tests/`, `__tests__/`, `src/test/`
-
-**Document**:
-- Testing framework and version
-- Mocking libraries
-- Coverage tools
-- Test runners
-- Additional plugins/extensions
-
-### Step 2: Analyze Test Organization
-
-**Examine test directory structure**:
-- Mirrored structure (`tests/` mirrors `src/`)
-- Colocated tests (`Component.test.ts` next to `Component.ts`)
-- By feature (`tests/features/`)
-- By type (`tests/unit/`, `tests/integration/`)
-
-**Extract naming patterns**:
-- Test file naming (`test_*.py`, `*.test.ts`, `*Test.java`, `*_test.go`)
-- Test function/method naming conventions
-- Test suite organization (describe blocks, test classes)
-
-### Step 3: Extract Test Patterns
-
-**Analyze 10-20 existing test files** to identify:
-- Test structure pattern (AAA, Given-When-Then, BDD)
-- Async test handling (if applicable)
-- Mock setup patterns
-- Assertion styles
+### Step 1: Discover Testing Stack
+
+Analyze:
+- Package files for test framework and dependencies
+- Existing test files for patterns
+- Test config files for settings
+- `.codemie/guides/` folder if exists
+
+Extract:
+| Item | Source |
+|------|--------|
+| Framework + version | package.json, pyproject.toml, pom.xml |
+| Plugins/extensions | Same + test configs |
+| Mock library | Import statements in test files |
+| Test directory | Project structure |
+| Naming convention | Existing test file names |
+
+### Step 2: Identify Patterns
+
+From 5-10 existing test files, extract:
+- Test structure (AAA, Given-When-Then, Table-driven)
+- Async handling pattern
+- Mock setup approach
 - Fixture/setup patterns
-- Error testing approaches
-
-### Step 4: Identify Project-Specific Rules
-
-**Critical paths**: What's most important to test?
-- Authentication/authorization
-- Payment processing
-- Data validation
-- Critical business logic
-- API endpoints
-
-**Trivial code to avoid testing**:
-- Framework-generated code
-- Simple getters/setters
-- Model defaults
-- Pass-through methods
-
-### Step 5: Extract Mocking Conventions
+- Assertion style
 
-**Python-specific**: "Patch where USED, not where DEFINED"
-**JavaScript-specific**: Module mocking with `jest.mock()`
-**Java-specific**: Annotation-based mocking with Mockito
-**Go-specific**: Interface-based mocking
+### Step 3: Document Mocking Rule
 
-### Step 6: Document Test Commands
+**Critical** - Identify the correct mocking approach:
 
-**Extract from**:
-- `package.json` scripts
-- `Makefile` targets
-- CI/CD config files (`.github/workflows/`, `.gitlab-ci.yml`)
-- Build tool configs (`pom.xml`, `build.gradle`)
+| Language | Rule |
+|----------|------|
+| Python | Patch where USED, not DEFINED |
+| JavaScript | jest.mock() at module level |
+| Java | @Mock + @InjectMocks |
+| Go | Interface-based mocks |
 
-### Step 7: Identify Quality Standards
+### Step 4: Create Concrete Examples
 
-**Coverage requirements**: Extract from:
-- `.coveragerc`, `jest.config.js`, `sonar-project.properties`
-- CI/CD quality gates
-- Project documentation
-
-**Performance standards**:
-- Expected test execution time
-- Timeout configurations
-- Parallel execution settings
-
-### Step 8: Populate Language-Specific Examples
-
-**For each essential test pattern**, create examples using:
+For each essential pattern, generate examples using:
 - Project's actual language syntax
-- Project's testing framework
-- Project's mocking library
-- Project's common domain objects
-- Project's error types
-
-### Validation Checklist
-
-- [ ] Testing framework and version identified
-- [ ] Test organization pattern documented
-- [ ] All 5 essential test patterns have language-specific examples
-- [ ] Mocking rules clearly stated with examples
-- [ ] Project-specific critical paths identified
-- [ ] Trivial code patterns documented
-- [ ] Test commands extracted and validated
-- [ ] Coverage requirements documented
-- [ ] All [PLACEHOLDERS] replaced with actual values
-- [ ] Examples use project's actual syntax and conventions
-
----
-
-## Multi-Language Support Matrix
-
-**[INSTRUCTIONS FOR GENERATION]**: Use this matrix to ensure language-specific customization:
-
-| Language | Framework | Mocking | Async | Pattern | File Naming |
-|----------|-----------|---------|-------|---------|-------------|
-| Python | pytest, unittest | unittest.mock, pytest-mock | @pytest.mark.asyncio | AAA | test_*.py |
-| JavaScript/TypeScript | Jest, Mocha, Jasmine | jest.mock, sinon | async/await | AAA/BDD | *.test.ts |
-| Java | JUnit 5, TestNG | Mockito, EasyMock | CompletableFuture | Given-When-Then | *Test.java |
-| Go | testing package | testify/mock | goroutines/channels | Table-driven | *_test.go |
-| C# | xUnit, NUnit, MSTest | Moq, NSubstitute | async/await | AAA | *Tests.cs |
-| Ruby | RSpec, Minitest | RSpec mocks | async gems | BDD | *_spec.rb |
-| Rust | cargo test | mockall | async-std/tokio | Result-based | tests/*.rs |
-
-**Key Customization Points per Language**:
-1. **Assertions**: `assert` vs `expect` vs `assertThat`
-2. **Mocking**: Import patching vs interface mocking vs annotation-based
-3. **Async**: Decorators vs keywords vs test runners
-4. **Organization**: Mirror source vs colocate vs separate directory
-5. **Setup/Teardown**: Fixtures vs beforeEach vs setUp vs test tables
-
-The goal is to produce an agent that generates tests perfectly aligned with the project's testing framework, conventions, and quality standards.
+- Project's test framework
+- Project's mock library
+- Realistic method/class names from codebase
+
+### Step 5: Extract Test Commands
+
+From package.json scripts, Makefile, or CI config:
+- Run all tests
+- Run single file
+- Run with coverage
+- Run specific test
+
+### Step 6: Finalize Agent
+
+- Remove all `[GENERATION INSTRUCTION]` blocks
+- Remove this "Generation Instructions" section
+- Replace all `[PLACEHOLDERS]` with project values
+- Include 1-2 concrete examples per pattern
+- **Target agent size: 100-150 lines**
+
+### Validation
+
+- [ ] Framework and version specified
+- [ ] Mocking rule clearly stated with example
+- [ ] All 5 patterns have project-specific examples
+- [ ] Test commands are accurate
+- [ ] No `[PLACEHOLDERS]` remain
+- [ ] No generation instructions remain
+- [ ] Agent under 150 lines