opencode-agent-kit 1.0.0

package/template/.opencode/skills/jetpack-compose/SKILL.md

@@ -0,0 +1,420 @@
+---
+name: android-jetpack-compose
+user-invocable: false
+description: Use when building Android UIs with Jetpack Compose, managing state with remember/mutableStateOf, or implementing declarative UI patterns.
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Grep
+  - Glob
+---
+
+# Android - Jetpack Compose
+
+Modern declarative UI toolkit for building native Android interfaces.
+
+## Key Concepts
+
+### State Management
+
+Compose provides several ways to manage state:
+
+- **remember**: Survives recomposition
+- **rememberSaveable**: Survives configuration changes
+- **mutableStateOf**: Creates observable state
+- **derivedStateOf**: Computed state that updates when dependencies change
+
+```kotlin
+@Composable
+fun Counter() {
+    var count by remember { mutableStateOf(0) }
+
+    Column {
+        Text("Count: $count")
+        Button(onClick = { count++ }) {
+            Text("Increment")
+        }
+    }
+}
+
+// With saveable for configuration changes
+@Composable
+fun SearchField() {
+    var query by rememberSaveable { mutableStateOf("") }
+
+    TextField(
+        value = query,
+        onValueChange = { query = it },
+        placeholder = { Text("Search...") }
+    )
+}
+```
+
+### State Hoisting
+
+Lift state up to make composables stateless and reusable:
+
+```kotlin
+// Stateless composable
+@Composable
+fun NameInput(
+    name: String,
+    onNameChange: (String) -> Unit,
+    modifier: Modifier = Modifier
+) {
+    TextField(
+        value = name,
+        onValueChange = onNameChange,
+        label = { Text("Name") },
+        modifier = modifier
+    )
+}
+
+// Stateful parent
+@Composable
+fun UserForm() {
+    var name by remember { mutableStateOf("") }
+
+    NameInput(
+        name = name,
+        onNameChange = { name = it }
+    )
+}
+```
+
+### ViewModel Integration
+
+```kotlin
+class UserViewModel : ViewModel() {
+    private val _uiState = MutableStateFlow(UserUiState())
+    val uiState: StateFlow<UserUiState> = _uiState.asStateFlow()
+
+    fun updateName(name: String) {
+        _uiState.update { it.copy(name = name) }
+    }
+
+    fun saveUser() {
+        viewModelScope.launch {
+            _uiState.update { it.copy(isLoading = true) }
+            try {
+                userRepository.save(_uiState.value.toUser())
+                _uiState.update { it.copy(isLoading = false, isSaved = true) }
+            } catch (e: Exception) {
+                _uiState.update { it.copy(isLoading = false, error = e.message) }
+            }
+        }
+    }
+}
+
+@Composable
+fun UserScreen(viewModel: UserViewModel = viewModel()) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+
+    UserContent(
+        uiState = uiState,
+        onNameChange = viewModel::updateName,
+        onSave = viewModel::saveUser
+    )
+}
+```
+
+## Best Practices
+
+### Composable Function Guidelines
+
+```kotlin
+// Use Modifier as first optional parameter
+@Composable
+fun CustomCard(
+    title: String,
+    modifier: Modifier = Modifier,
+    onClick: () -> Unit = {}
+) {
+    Card(
+        modifier = modifier.clickable(onClick = onClick)
+    ) {
+        Text(
+            text = title,
+            modifier = Modifier.padding(16.dp)
+        )
+    }
+}
+
+// Use slot APIs for flexible content
+@Composable
+fun CustomScaffold(
+    topBar: @Composable () -> Unit = {},
+    bottomBar: @Composable () -> Unit = {},
+    content: @Composable (PaddingValues) -> Unit
+) {
+    Scaffold(
+        topBar = topBar,
+        bottomBar = bottomBar,
+        content = content
+    )
+}
+```
+
+### Efficient Recomposition
+
+```kotlin
+// Use keys for list items
+@Composable
+fun UserList(users: List<User>) {
+    LazyColumn {
+        items(
+            items = users,
+            key = { it.id }  // Stable key for efficient updates
+        ) { user ->
+            UserItem(user)
+        }
+    }
+}
+
+// Use derivedStateOf for expensive computations
+@Composable
+fun FilteredList(items: List<Item>, query: String) {
+    val filteredItems by remember(items, query) {
+        derivedStateOf {
+            items.filter { it.name.contains(query, ignoreCase = true) }
+        }
+    }
+
+    LazyColumn {
+        items(filteredItems) { item ->
+            ItemRow(item)
+        }
+    }
+}
+```
+
+### Side Effects
+
+```kotlin
+// LaunchedEffect for coroutine-based side effects
+@Composable
+fun UserProfile(userId: String, viewModel: UserViewModel) {
+    LaunchedEffect(userId) {
+        viewModel.loadUser(userId)
+    }
+
+    // UI content
+}
+
+// DisposableEffect for cleanup
+@Composable
+fun LifecycleAwareComponent(lifecycle: Lifecycle) {
+    DisposableEffect(lifecycle) {
+        val observer = LifecycleEventObserver { _, event ->
+            // Handle lifecycle events
+        }
+        lifecycle.addObserver(observer)
+
+        onDispose {
+            lifecycle.removeObserver(observer)
+        }
+    }
+}
+
+// SideEffect for non-suspend side effects
+@Composable
+fun AnalyticsScreen(screenName: String) {
+    SideEffect {
+        analytics.logScreenView(screenName)
+    }
+}
+```
+
+## Common Patterns
+
+### Navigation with Navigation Compose
+
+```kotlin
+@Composable
+fun AppNavigation() {
+    val navController = rememberNavController()
+
+    NavHost(navController = navController, startDestination = "home") {
+        composable("home") {
+            HomeScreen(
+                onNavigateToDetail = { id ->
+                    navController.navigate("detail/$id")
+                }
+            )
+        }
+        composable(
+            route = "detail/{itemId}",
+            arguments = listOf(navArgument("itemId") { type = NavType.StringType })
+        ) { backStackEntry ->
+            val itemId = backStackEntry.arguments?.getString("itemId")
+            DetailScreen(itemId = itemId)
+        }
+    }
+}
+```
+
+### Material 3 Theming
+
+```kotlin
+@Composable
+fun AppTheme(
+    darkTheme: Boolean = isSystemInDarkTheme(),
+    content: @Composable () -> Unit
+) {
+    val colorScheme = when {
+        darkTheme -> darkColorScheme(
+            primary = Purple80,
+            secondary = PurpleGrey80,
+            tertiary = Pink80
+        )
+        else -> lightColorScheme(
+            primary = Purple40,
+            secondary = PurpleGrey40,
+            tertiary = Pink40
+        )
+    }
+
+    MaterialTheme(
+        colorScheme = colorScheme,
+        typography = Typography,
+        content = content
+    )
+}
+
+// Using theme values
+@Composable
+fun ThemedCard() {
+    Card(
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.surfaceVariant
+        )
+    ) {
+        Text(
+            text = "Themed content",
+            style = MaterialTheme.typography.bodyLarge,
+            color = MaterialTheme.colorScheme.onSurfaceVariant
+        )
+    }
+}
+```
+
+### Lists and Grids
+
+```kotlin
+@Composable
+fun ProductGrid(products: List<Product>) {
+    LazyVerticalGrid(
+        columns = GridCells.Adaptive(minSize = 160.dp),
+        contentPadding = PaddingValues(16.dp),
+        horizontalArrangement = Arrangement.spacedBy(16.dp),
+        verticalArrangement = Arrangement.spacedBy(16.dp)
+    ) {
+        items(products, key = { it.id }) { product ->
+            ProductCard(product)
+        }
+    }
+}
+
+// Sticky headers
+@Composable
+fun ContactList(contacts: Map<Char, List<Contact>>) {
+    LazyColumn {
+        contacts.forEach { (initial, contactsForInitial) ->
+            stickyHeader {
+                Text(
+                    text = initial.toString(),
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .background(MaterialTheme.colorScheme.surface)
+                        .padding(16.dp),
+                    style = MaterialTheme.typography.titleMedium
+                )
+            }
+            items(contactsForInitial) { contact ->
+                ContactItem(contact)
+            }
+        }
+    }
+}
+```
+
+## Anti-Patterns
+
+### Avoid Side Effects in Composition
+
+Bad:
+
+```kotlin
+@Composable
+fun BadExample(viewModel: ViewModel) {
+    viewModel.loadData()  // Called on every recomposition!
+
+    Text("Data loaded")
+}
+```
+
+Good:
+
+```kotlin
+@Composable
+fun GoodExample(viewModel: ViewModel) {
+    LaunchedEffect(Unit) {
+        viewModel.loadData()
+    }
+
+    Text("Data loaded")
+}
+```
+
+### Don't Read State in Remember Block
+
+Bad:
+
+```kotlin
+@Composable
+fun BadCounter(initial: Int) {
+    // Won't update when initial changes
+    var count by remember { mutableStateOf(initial) }
+}
+```
+
+Good:
+
+```kotlin
+@Composable
+fun GoodCounter(initial: Int) {
+    var count by remember(initial) { mutableStateOf(initial) }
+}
+```
+
+### Avoid Heavy Computation During Composition
+
+Bad:
+
+```kotlin
+@Composable
+fun BadList(items: List<Item>) {
+    // Runs on every recomposition
+    val sorted = items.sortedBy { it.name }
+    LazyColumn { /* ... */ }
+}
+```
+
+Good:
+
+```kotlin
+@Composable
+fun GoodList(items: List<Item>) {
+    val sorted by remember(items) {
+        derivedStateOf { items.sortedBy { it.name } }
+    }
+    LazyColumn { /* ... */ }
+}
+```
+
+## Related Skills
+
+- **android-architecture**: MVVM and clean architecture patterns
+- **android-kotlin-coroutines**: Async operations in Compose

package/template/.opencode/skills/jpa-patterns/SKILL.md

@@ -0,0 +1,141 @@
+---
+name: jpa-patterns
+description: JPA/Hibernate patterns for entity design, relationships, query optimization, transactions, auditing, indexing, pagination, and pooling in Spring Boot.
+---
+
+# JPA/Hibernate Patterns
+
+Use for data modeling, repositories, and performance tuning in Spring Boot.
+
+## Entity Design
+
+```java
+@Entity
+@Table(name = "markets", indexes = {
+  @Index(name = "idx_markets_slug", columnList = "slug", unique = true)
+})
+@EntityListeners(AuditingEntityListener.class)
+public class MarketEntity {
+  @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
+  private Long id;
+
+  @Column(nullable = false, length = 200)
+  private String name;
+
+  @Column(nullable = false, unique = true, length = 120)
+  private String slug;
+
+  @Enumerated(EnumType.STRING)
+  private MarketStatus status = MarketStatus.ACTIVE;
+
+  @CreatedDate private Instant createdAt;
+  @LastModifiedDate private Instant updatedAt;
+}
+```
+
+Enable auditing:
+```java
+@Configuration
+@EnableJpaAuditing
+class JpaConfig {}
+```
+
+## Relationships and N+1 Prevention
+
+```java
+@OneToMany(mappedBy = "market", cascade = CascadeType.ALL, orphanRemoval = true)
+private List<PositionEntity> positions = new ArrayList<>();
+```
+
+- Default to lazy loading; use `JOIN FETCH` in queries when needed
+- Avoid `EAGER` on collections; use DTO projections for read paths
+
+```java
+@Query("select m from MarketEntity m left join fetch m.positions where m.id = :id")
+Optional<MarketEntity> findWithPositions(@Param("id") Long id);
+```
+
+## Repository Patterns
+
+```java
+public interface MarketRepository extends JpaRepository<MarketEntity, Long> {
+  Optional<MarketEntity> findBySlug(String slug);
+
+  @Query("select m from MarketEntity m where m.status = :status")
+  Page<MarketEntity> findByStatus(@Param("status") MarketStatus status, Pageable pageable);
+}
+```
+
+- Use projections for lightweight queries:
+```java
+public interface MarketSummary {
+  Long getId();
+  String getName();
+  MarketStatus getStatus();
+}
+Page<MarketSummary> findAllBy(Pageable pageable);
+```
+
+## Transactions
+
+- Annotate service methods with `@Transactional`
+- Use `@Transactional(readOnly = true)` for read paths to optimize
+- Choose propagation carefully; avoid long-running transactions
+
+```java
+@Transactional
+public Market updateStatus(Long id, MarketStatus status) {
+  MarketEntity entity = repo.findById(id)
+      .orElseThrow(() -> new EntityNotFoundException("Market"));
+  entity.setStatus(status);
+  return Market.from(entity);
+}
+```
+
+## Pagination
+
+```java
+PageRequest page = PageRequest.of(pageNumber, pageSize, Sort.by("createdAt").descending());
+Page<MarketEntity> markets = repo.findByStatus(MarketStatus.ACTIVE, page);
+```
+
+For cursor-like pagination, include `id > :lastId` in JPQL with ordering.
+
+## Indexing and Performance
+
+- Add indexes for common filters (`status`, `slug`, foreign keys)
+- Use composite indexes matching query patterns (`status, created_at`)
+- Avoid `select *`; project only needed columns
+- Batch writes with `saveAll` and `hibernate.jdbc.batch_size`
+
+## Connection Pooling (HikariCP)
+
+Recommended properties:
+```
+spring.datasource.hikari.maximum-pool-size=20
+spring.datasource.hikari.minimum-idle=5
+spring.datasource.hikari.connection-timeout=30000
+spring.datasource.hikari.validation-timeout=5000
+```
+
+For PostgreSQL LOB handling, add:
+```
+spring.jpa.properties.hibernate.jdbc.lob.non_contextual_creation=true
+```
+
+## Caching
+
+- 1st-level cache is per EntityManager; avoid keeping entities across transactions
+- For read-heavy entities, consider second-level cache cautiously; validate eviction strategy
+
+## Migrations
+
+- Use Flyway or Liquibase; never rely on Hibernate auto DDL in production
+- Keep migrations idempotent and additive; avoid dropping columns without plan
+
+## Testing Data Access
+
+- Prefer `@DataJpaTest` with Testcontainers to mirror production
+- Assert SQL efficiency using logs: set `logging.level.org.hibernate.SQL=DEBUG` and `logging.level.org.hibernate.orm.jdbc.bind=TRACE` for parameter values
+
+**Remember**: Keep entities lean, queries intentional, and transactions short. Prevent N+1 with fetch strategies and projections, and index for your read/write paths.