cc-codeconductor 0.2.1

package/presets/codex/skills/testing-strategy/SKILL.md

@@ -0,0 +1,479 @@
+---
+id: testing-strategy
+version: 1.0.0
+name: Testing Strategy
+description:
+  Provides expert knowledge of the testing pyramid, test design principles,
+  MockK patterns, and integration testing conventions for Spring Boot + Kotlin
+  projects.
+
+compatibility:
+  tools: [claude, codex, opencode]
+  stacks:
+    languages: [kotlin, java]
+    frameworks: [spring-boot, junit5, mockk, testcontainers, assertj]
+    databases: [postgresql, h2]
+
+risk:
+  level: low
+  can_execute_shell: false
+  can_modify_files: true
+  requires_network: false
+
+inputs:
+  - source_files
+  - test_files
+  - build.gradle.kts
+
+outputs:
+  - unit test classes
+  - integration test classes
+  - test data factories
+  - contract test scaffolding
+
+quality:
+  reviewed_by: codeconductor-core
+  version: 0.1.0
+---
+
+# Testing Strategy
+
+## Testing Pyramid
+
+```text
+       /\
+      /  \
+     / E2E\       10% — full API, happy path + main error cases
+    /------\
+   /  Integ \     20% — components with real dependencies (DB, HTTP)
+  /----------\
+ /    Unit    \   70% — isolated, mocked dependencies, fast
+/______________\
+```
+
+Unit tests are the foundation. They are fast, deterministic, and cheap to run.
+Integration tests validate that components work together. E2E tests validate
+that the system works end to end — keep them minimal.
+
+If you find yourself writing more integration tests than unit tests, the code
+under test has too many responsibilities bundled together.
+
+## Test Naming Convention
+
+Format: `should [expected behavior] when [condition]`
+
+```kotlin
+@Test
+fun `should return user when found by id`() { ... }
+
+@Test
+fun `should return 404 when user does not exist`() { ... }
+
+@Test
+fun `should throw ConflictException when email already exists`() { ... }
+
+@Test
+fun `should not return deleted users in list`() { ... }
+```
+
+Group related tests with `@Nested`:
+
+```kotlin
+@ExtendWith(MockKExtension::class)
+class UserServiceTest {
+
+    @Nested
+    inner class GetById {
+        @Test
+        fun `should return user when found`() { ... }
+
+        @Test
+        fun `should return NotFound when user does not exist`() { ... }
+    }
+
+    @Nested
+    inner class Create {
+        @Test
+        fun `should create and return user when email is unique`() { ... }
+
+        @Test
+        fun `should throw ConflictException when email already exists`() { ... }
+    }
+}
+```
+
+## Unit Test Structure (AAA)
+
+Every test follows Arrange → Act → Assert. Use blank lines to separate each
+phase.
+
+```kotlin
+@Test
+fun `should return user when found by id`() {
+    // Arrange
+    val userId = UUID.randomUUID()
+    val user = User(id = userId, email = "user@example.com", name = "Test User")
+    every { userRepository.findById(userId) } returns Optional.of(user)
+
+    // Act
+    val result = userService.getById(userId)
+
+    // Assert
+    assertThat(result).isInstanceOf(UserResult.Found::class.java)
+    val found = result as UserResult.Found
+    assertThat(found.user.id).isEqualTo(userId)
+    verify(exactly = 1) { userRepository.findById(userId) }
+}
+```
+
+No inline comments between phases once the structure is clear. The blank lines
+are enough.
+
+## What NOT to Test
+
+**Framework wiring.** Spring handles dependency injection. Do not write tests
+that verify `@Autowired` works.
+
+**JPA mapping.** Do not test that `@Column(name = "email")` maps to the right
+column. That is Hibernate's job.
+
+**Trivial getters and setters.** A data class property has no logic. There is
+nothing to test.
+
+**Private methods directly.** Private methods are implementation details. Test
+them through the public behavior that uses them. If a private method is complex
+enough to need its own test, it should be extracted into a separate class.
+
+**Implementation, not behavior.** Tests that verify HOW something is done (mock
+call order, internal state) are brittle. Test WHAT the output or side effect is.
+
+```kotlin
+// bad — tests implementation detail
+verify { userRepository.findById(any()) }
+verify { cacheService.put(any(), any()) }
+verify(ordering = Ordering.ORDERED) {   // this is too coupled to internals
+    userRepository.findById(userId)
+    cacheService.put(userId, user)
+}
+
+// good — tests observable behavior
+assertThat(result).isEqualTo(expectedUser)
+```
+
+## MockK Patterns
+
+### Basic Setup
+
+```kotlin
+@ExtendWith(MockKExtension::class)
+class UserServiceTest {
+
+    @MockK
+    private lateinit var userRepository: UserRepository
+
+    @MockK
+    private lateinit var emailService: EmailService
+
+    private lateinit var userService: UserService
+
+    @BeforeEach
+    fun setUp() {
+        userService = UserService(userRepository, emailService)
+    }
+}
+```
+
+### Stubbing
+
+```kotlin
+// Return value
+every { userRepository.findById(userId) } returns Optional.of(user)
+
+// Return null (for nullable return types)
+every { userRepository.findByEmail(any()) } returns null
+
+// Throw exception
+every { userRepository.save(any()) } throws DataIntegrityViolationException("Duplicate")
+
+// Return different values on successive calls
+every { userRepository.findById(any()) } returnsMany listOf(Optional.of(user), Optional.empty())
+
+// Answer with computation
+every { userRepository.save(any()) } answers { firstArg() }
+```
+
+### Verification
+
+```kotlin
+// Verify called exactly once with specific argument
+verify(exactly = 1) { userRepository.findById(userId) }
+
+// Verify called with any argument
+verify { emailService.sendWelcome(any()) }
+
+// Verify never called
+verify(exactly = 0) { emailService.sendWelcome(any()) }
+
+// Verify called with specific argument
+verify { emailService.sendWelcome(match { it.email == "user@example.com" }) }
+```
+
+### Relaxed Mocks
+
+```kotlin
+// relaxed = true — returns default values (null, 0, false, empty list)
+// Use only when you do not care about the return value of any method
+val logger = mockk<Logger>(relaxed = true)
+```
+
+Do not use `relaxed = true` on mocks where you need to verify behavior — a
+relaxed mock does not fail on unexpected calls, which can hide bugs.
+
+### Coroutines
+
+```kotlin
+// Stubbing suspend functions
+coEvery { userRepository.findById(userId) } returns user
+
+// Verifying suspend functions
+coVerify(exactly = 1) { userRepository.findById(userId) }
+```
+
+### Argument Matchers
+
+```kotlin
+// Any value
+every { service.process(any()) } returns result
+
+// Specific type
+every { service.process(any<UserRequest>()) } returns result
+
+// Custom predicate
+every { service.notify(match { it.email.endsWith("@example.com") }) } just Runs
+
+// Capture for assertion
+val slot = slot<User>()
+every { userRepository.save(capture(slot)) } returns savedUser
+// ... trigger the action ...
+assertThat(slot.captured.email).isEqualTo("expected@example.com")
+```
+
+## Integration Test Patterns
+
+### Controller Tests with MockMvc
+
+```kotlin
+@SpringBootTest
+@AutoConfigureMockMvc
+class UserControllerTest {
+
+    @Autowired
+    private lateinit var mockMvc: MockMvc
+
+    @Autowired
+    private lateinit var objectMapper: ObjectMapper
+
+    @Test
+    fun `should return 200 with user when found`() {
+        mockMvc.perform(
+            get("/api/v1/users/${existingUser.id}")
+                .contentType(MediaType.APPLICATION_JSON)
+        )
+            .andExpect(status().isOk)
+            .andExpect(jsonPath("$.email").value(existingUser.email))
+            .andExpect(jsonPath("$.id").value(existingUser.id.toString()))
+    }
+
+    @Test
+    fun `should return 400 when request body is invalid`() {
+        val invalidRequest = mapOf("email" to "not-an-email")
+
+        mockMvc.perform(
+            post("/api/v1/users")
+                .contentType(MediaType.APPLICATION_JSON)
+                .content(objectMapper.writeValueAsString(invalidRequest))
+        )
+            .andExpect(status().isBadRequest)
+            .andExpect(jsonPath("$.code").value("VALIDATION_ERROR"))
+    }
+
+    @Test
+    fun `should return 404 when user is not found`() {
+        mockMvc.perform(get("/api/v1/users/${UUID.randomUUID()}"))
+            .andExpect(status().isNotFound)
+    }
+}
+```
+
+`@AutoConfigureMockMvc` configures MockMvc without starting a real HTTP server.
+The test is faster than `RANDOM_PORT` but still tests the full Spring MVC stack.
+
+Use `RANDOM_PORT` only when you need real HTTP (e.g., testing HTTP client
+behavior, WebSockets, or SSE).
+
+### Database Tests with Testcontainers
+
+```kotlin
+@SpringBootTest
+@Testcontainers
+class UserRepositoryIntegrationTest {
+
+    companion object {
+        @Container
+        @JvmStatic
+        val postgres = PostgreSQLContainer<Nothing>("postgres:16").apply {
+            withDatabaseName("testdb")
+            withUsername("test")
+            withPassword("test")
+        }
+
+        @DynamicPropertySource
+        @JvmStatic
+        fun overrideProperties(registry: DynamicPropertyRegistry) {
+            registry.add("spring.datasource.url", postgres::getJdbcUrl)
+            registry.add("spring.datasource.username", postgres::getUsername)
+            registry.add("spring.datasource.password", postgres::getPassword)
+        }
+    }
+
+    @Autowired
+    private lateinit var userRepository: UserRepository
+
+    @Test
+    fun `should enforce unique email at database level`() {
+        userRepository.save(User(email = "unique@example.com", name = "First"))
+        assertThrows<DataIntegrityViolationException> {
+            userRepository.save(User(email = "unique@example.com", name = "Second"))
+        }
+    }
+}
+```
+
+Share the container across test classes using a base class with `@Container` on
+a static field. Testcontainers reuses the same container if the configuration is
+identical.
+
+### Seed Data with @Sql
+
+```kotlin
+@SpringBootTest
+@AutoConfigureMockMvc
+@Sql("/test-data/users.sql")   // runs before each test in this class
+class UserControllerTest { ... }
+
+// Or per-test
+@Test
+@Sql("/test-data/users-with-orders.sql")
+fun `should return orders when user has orders`() { ... }
+```
+
+SQL files go in `src/test/resources/test-data/`. Use descriptive names that
+explain what state they create, not what feature they serve.
+
+## Test Data Factories
+
+Never hardcode UUIDs or share mutable state between tests.
+
+```kotlin
+object UserTestFactory {
+
+    fun create(
+        id: UUID = UUID.randomUUID(),
+        email: String = "user-${UUID.randomUUID()}@example.com",
+        name: String = "Test User",
+        role: UserRole = UserRole.USER
+    ): User = User(
+        id = id,
+        email = email,
+        name = name,
+        role = role
+    )
+
+    fun createRequest(
+        email: String = "user-${UUID.randomUUID()}@example.com",
+        name: String = "Test User"
+    ): CreateUserRequest = CreateUserRequest(
+        email = email,
+        name = name
+    )
+
+    fun createAdmin(): User = create(role = UserRole.ADMIN)
+
+    fun createList(count: Int): List<User> = (1..count).map { create() }
+}
+```
+
+Usage in tests:
+
+```kotlin
+val user = UserTestFactory.create(email = "specific@example.com")
+val admin = UserTestFactory.createAdmin()
+val users = UserTestFactory.createList(5)
+```
+
+Default values use `UUID.randomUUID()` to ensure tests do not share state
+through hardcoded IDs or emails.
+
+## When Tests Are Required
+
+**New behavior.** Every new feature requires at minimum one unit test and one
+integration test covering the happy path. Edge cases and error paths require
+additional unit tests.
+
+**Bug fix.** Write a regression test that reproduces the bug before fixing it.
+The test must fail before the fix and pass after. This prevents the bug from
+reappearing silently.
+
+```kotlin
+// Example: bug where findByEmail returned deleted users
+@Test
+fun `should not return deleted user — regression for bug #42`() {
+    val user = userRepository.save(UserTestFactory.create(email = "gone@example.com"))
+    userRepository.delete(user)
+    val result = userRepository.findByEmail("gone@example.com")
+    assertThat(result).isNull()
+}
+```
+
+**Refactor.** Do not write new tests. The existing tests must pass unchanged. If
+they do not, the refactor changed behavior — that is a bug.
+
+**High-risk paths.** Security, payment processing, data migrations, and
+permission checks require contract tests in addition to unit and integration
+tests. These paths have severe consequences if broken.
+
+## CI Integration
+
+Tests must run in CI on every pull request. The pipeline must fail if any test
+fails.
+
+Recommended test execution order:
+
+1. Unit tests (fastest — fail fast)
+2. Integration tests with H2 (`@DataJpaTest`)
+3. Integration tests with Testcontainers (slowest — run last)
+
+Separate test tasks in Gradle:
+
+```kotlin
+// build.gradle.kts
+tasks.register<Test>("integrationTest") {
+    description = "Runs integration tests"
+    group = "verification"
+    useJUnitPlatform {
+        includeTags("integration")
+    }
+    shouldRunAfter(tasks.test)
+}
+```
+
+Tag integration tests:
+
+```kotlin
+@Tag("integration")
+@SpringBootTest
+class UserRepositoryIntegrationTest { ... }
+```
+
+Do not mix unit and integration test tags in the same class. A test class is
+either one or the other.

package/presets/opencode/README.md

@@ -0,0 +1,191 @@
+# OpenCode Preset for CodeConductor
+
+## Model Selection Guide
+
+This preset supports both **Claude (Anthropic)** and **OpenCode Go (Chinese
+providers)** models.
+
+---
+
+## Model Reference
+
+### Claude Models (Anthropic)
+
+| Model                       | Strength                        | Best For                        |
+| --------------------------- | ------------------------------- | ------------------------------- |
+| `claude-opus-4-7`           | Complex reasoning, architecture | Architect, complex design       |
+| `claude-sonnet-4-6`         | Balanced, general purpose       | Default for most agents         |
+| `claude-haiku-4-5-20251001` | Fast, lightweight               | Task Coach, Docs, Repo Explorer |
+
+### OpenCode Go Models (Chinese Providers)
+
+| Model             | Provider        | Strength                         | Best For                   |
+| ----------------- | --------------- | -------------------------------- | -------------------------- |
+| `deepseek-v4-pro` | DeepSeek        | Reasoning complejo, arquitectura | Architect, orchestrator    |
+| `mimo-v2.5-pro`   | MiniMax         | Razonamiento matemático, código  | Implementer                |
+| `minimax-m2.7`    | MiniMax         | Tareas equilibradas              | Tester, orchestrator       |
+| `qwen-3.6-plus`   | Qwen            | Rápido, eficiente                | Reviewer, Task Coach, Docs |
+| `kimi-k2-6`       | Kimi (Moonshot) | Conversación natural             | Task Coach, Docs           |
+
+---
+
+## Agent Model Matrix
+
+| Agent             | Claude (Default)            | OpenCode Go (Recommended) | Alternative       |
+| ----------------- | --------------------------- | ------------------------- | ----------------- |
+| **Orchestrator**  | `claude-sonnet-4-6`         | `deepseek-v4-pro`         | `minimax-m2.7`    |
+| **Architect**     | `claude-opus-4-7`           | `deepseek-v4-pro`         | `mimo-v2.5-pro`   |
+| **Implementer**   | `claude-sonnet-4-6`         | `mimo-v2.5-pro`           | `minimax-m2.7`    |
+| **Tester**        | `claude-sonnet-4-6`         | `minimax-m2.7`            | `deepseek-v4-pro` |
+| **Reviewer**      | `claude-sonnet-4-6`         | `qwen-3.6-plus`           | `minimax-m2.7`    |
+| **Task Coach**    | `claude-haiku-4-5-20251001` | `qwen-3.6-plus`           | `kimi-k2.6`       |
+| **Docs**          | `claude-haiku-4-5-20251001` | `qwen-3.6-plus`           | `kimi-k2.6`       |
+| **Repo Explorer** | `claude-haiku-4-5-20251001` | `qwen-3.6-plus`           | `kimi-k2.6`       |
+
+---
+
+## Agent Modes
+
+| Agent             | Mode      | Description                                          |
+| ----------------- | --------- | ---------------------------------------------------- |
+| **Orchestrator**  | primary   | Main coordinator — Tab to switch to it               |
+| **Architect**     | subagent  | Invoked by Orchestrator for design work              |
+| **Implementer**   | subagent  | Invoked by Orchestrator for code implementation      |
+| **Tester**        | subagent  | Invoked by Orchestrator for test generation          |
+| **Reviewer**      | subagent  | Invoked by Orchestrator for code review              |
+| **Task Coach**    | subagent  | Invoked by Orchestrator for intake clarification     |
+| **Docs**          | subagent  | Invoked by Orchestrator for documentation updates    |
+| **Repo Explorer** | subagent  | Invoked by Orchestrator for codebase exploration     |
+
+---
+
+## Permission System
+
+This preset uses OpenCode's permission system (v1.1.1+) with granular control:
+
+- **Global defaults**: Most operations require approval (`ask`)
+- **Read access**: Allowed by default, with sensitive files denied
+- **Write/Edit**: Requires approval, with protected paths denied
+- **Bash commands**: Read-only git commands allowed, destructive commands denied
+- **Agent-specific**: Each agent has tailored permissions matching its role
+
+### Protected Paths
+
+The following paths are denied by default:
+
+- `.env`, `.env.*` — environment secrets
+- `secrets/**` — secret files
+- `~/.ssh/**`, `~/.aws/**`, `~/.kube/**` — system credentials
+- `.git/**`, `.opencode/**`, `.claude/**` — tool configuration
+
+---
+
+## Model Selection by Task Complexity
+
+### Simple Tasks (Q&A, intake, documentation)
+
+**Recommended:** `qwen-3.6-plus` (OpenCode Go) or `claude-haiku-4-5-20251001`
+(Claude)
+
+- Task Coach intake
+- Repo Explorer mapping
+- Docs updates
+
+### Medium Tasks (Implementation, testing)
+
+**Recommended:** `mimo-v2.5-pro` or `minimax-m2.7` (OpenCode Go) or
+`claude-sonnet-4-6` (Claude)
+
+- Implementer code writing
+- Tester test generation
+- Reviewer standard reviews
+
+### Complex Tasks (Architecture, security, multi-agent coordination)
+
+**Recommended:** `deepseek-v4-pro` (OpenCode Go) or `claude-opus-4-7` (Claude)
+
+- Architect technical design
+- Orchestrator routing decisions
+- Reviewer security analysis
+
+---
+
+## Usage in Agent Contracts
+
+Each agent file in `agents/` contains a model selection table in its
+frontmatter:
+
+```yaml
+---
+description: ...
+# Model Selection
+| Provider | Model | Use Case |
+|----------|-------|----------|
+| Claude | claude-opus-4-7 | Complex architecture, ADRs |
+| OpenCode Go | deepseek-v4-pro | Best — excels at reasoning |
+---
+```
+
+To override, edit the `model` field in the agent's YAML frontmatter or use the
+configuration in `opencode.jsonc`.
+
+---
+
+## Configuration Priority
+
+1. **Agent frontmatter** — highest priority (per-agent override)
+2. **opencode.jsonc model override** — applies to specific agents
+3. **opencode.jsonc default** — fallback for all agents
+
+---
+
+## Environment Variables
+
+OpenCode Go requires appropriate API keys. Set these in your environment:
+
+```bash
+# DeepSeek
+export DEEPSEEK_API_KEY="your-key"
+
+# Qwen (Alibaba)
+export DASHSCOPE_API_KEY="your-key"
+
+# MiniMax
+export MINIMAX_API_KEY="your-key"
+
+# Kimi (Moonshot)
+export KIMI_API_KEY="your-key"
+```
+
+---
+
+## Selecting Between Claude and OpenCode Go
+
+| Scenario                        | Recommended                                        |
+| ------------------------------- | -------------------------------------------------- |
+| Complex reasoning, architecture | OpenCode Go (`deepseek-v4-pro`) or Claude (`opus`) |
+| Fast iteration, simple tasks    | OpenCode Go (`qwen-3.6-plus`) or Claude (`haiku`)  |
+| Code implementation             | OpenCode Go (`mimo-v2.5-pro`) or Claude (`sonnet`) |
+| Budget constraints              | OpenCode Go (generally lower cost)                 |
+| Availability issues             | Switch to alternative from the matrix              |
+
+## Approach
+
+- Think before acting. Read existing files before writing code.
+- Be concise in output but thorough in reasoning.
+- Prefer editing over rewriting whole files.
+- Do not re-read files you have already read unless the file may have changed.
+- Skip files over 100KB unless explicitly required.
+- Suggest running /cost when a session is running long to monitor cache ratio.
+- Recommend starting a new session when switching to an unrelated task.
+- Test your code before declaring done.
+- No sycophantic openers or closing fluff.
+- Keep solutions simple and direct.
+- User instructions always override this file.
+- When using tools, be precise and minimal with context.
+
+## Context Budget
+
+- If the task type differs from the previous one, execute "/clear" before
+  starting.
+- Delegate verbose operations to sub-agents.