opencode-skills-collection 3.0.42 → 3.0.43

package/bundled-skills/android-dev/references/kmm.md

@@ -0,0 +1,206 @@
+# Kotlin Multiplatform (KMM) Reference
+
+## Project Structure
+
+```
+project/
+├── shared/                          # Shared KMM module
+│   ├── src/
+│   │   ├── commonMain/kotlin/       # Business logic, domain, data
+│   │   │   ├── domain/
+│   │   │   │   ├── model/
+│   │   │   │   ├── repository/      # Interfaces
+│   │   │   │   └── usecase/
+│   │   │   ├── data/
+│   │   │   │   ├── remote/          # Ktor client + DTOs
+│   │   │   │   ├── local/           # SQLDelight DAOs
+│   │   │   │   └── repository/      # Implementations
+│   │   │   └── di/                  # Koin modules
+│   │   ├── androidMain/kotlin/      # Android-specific actual implementations
+│   │   └── iosMain/kotlin/          # iOS-specific actual (if needed)
+│   └── build.gradle.kts
+├── androidApp/                      # Android app module
+│   ├── src/main/java/
+│   │   ├── ui/                      # Jetpack Compose screens
+│   │   ├── presentation/            # Android ViewModels
+│   │   └── di/                      # Android-specific DI
+│   └── build.gradle.kts
+└── build.gradle.kts
+```
+
+## Shared Module: Ktor HTTP Client
+
+```kotlin
+// commonMain
+expect fun httpClient(config: HttpClientConfig<*>.() -> Unit): HttpClient
+
+// androidMain
+actual fun httpClient(config: HttpClientConfig<*>.() -> Unit): HttpClient =
+    HttpClient(OkHttp) {
+        config(this)
+        engine { addInterceptor(/* logging, auth */) }
+    }
+
+// Shared usage
+val client = httpClient {
+    install(ContentNegotiation) { json() }
+    install(HttpTimeout) { requestTimeoutMillis = 10_000 }
+    defaultRequest {
+        url(BuildKonfig.BASE_URL)
+        header(HttpHeaders.ContentType, ContentType.Application.Json)
+    }
+}
+```
+
+## SQLDelight Setup
+
+```sql
+-- ItemEntity.sq
+CREATE TABLE ItemEntity (
+    id TEXT NOT NULL PRIMARY KEY,
+    title TEXT NOT NULL,
+    updatedAt INTEGER NOT NULL DEFAULT 0
+);
+
+selectAll:
+SELECT * FROM ItemEntity ORDER BY updatedAt DESC;
+
+upsertItem:
+INSERT OR REPLACE INTO ItemEntity (id, title, updatedAt)
+VALUES (?, ?, ?);
+```
+
+```kotlin
+// commonMain — Database driver expect/actual
+expect class DatabaseDriverFactory {
+    fun createDriver(): SqlDriver
+}
+
+// androidMain
+actual class DatabaseDriverFactory(private val context: Context) {
+    actual fun createDriver(): SqlDriver =
+        AndroidSqliteDriver(AppDatabase.Schema, context, "app.db")
+}
+```
+
+## Shared Repository
+
+```kotlin
+// commonMain
+class ItemRepositoryImpl(
+    private val remoteSource: ItemRemoteDataSource,
+    private val localSource: ItemLocalDataSource,
+) : ItemRepository {
+
+    override fun observeItems(): Flow<List<Item>> =
+        localSource.observeAll().map { entities ->
+            entities.map { it.toDomain() }
+        }
+
+    override suspend fun refreshItems(): Result<Unit> = runCatching {
+        val items = remoteSource.fetchItems()
+        localSource.upsertAll(items.map { it.toEntity() })
+    }
+}
+```
+
+## Android ViewModel consuming shared Flow
+
+```kotlin
+@HiltViewModel
+class HomeViewModel @Inject constructor(
+    private val observeItems: ObserveItemsUseCase,    // from shared module
+    private val refreshItems: RefreshItemsUseCase     // from shared module
+) : ViewModel() {
+
+    val uiState = observeItems()
+        .map { HomeUiState.Success(it) as HomeUiState }
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(5_000),
+            initialValue = HomeUiState.Loading
+        )
+}
+```
+
+## Koin DI (Shared + Android)
+
+```kotlin
+// commonMain — shared Koin modules
+val sharedModule = module {
+    single { DatabaseDriverFactory(get()) }
+    single { AppDatabase(get<DatabaseDriverFactory>().createDriver()) }
+    single<ItemRepository> { ItemRepositoryImpl(get(), get()) }
+    factory { ObserveItemsUseCase(get()) }
+    factory { RefreshItemsUseCase(get()) }
+}
+
+// androidApp — Android-specific module
+val androidModule = module {
+    single<Context> { androidApplication() }
+    viewModel { HomeViewModel(get(), get()) }
+}
+
+// Application class
+class MyApp : Application() {
+    override fun onCreate() {
+        super.onCreate()
+        startKoin {
+            androidContext(this@MyApp)
+            modules(sharedModule, androidModule)
+        }
+    }
+}
+```
+
+## Key Gradle Dependencies (shared/build.gradle.kts)
+
+```kotlin
+kotlin {
+    androidTarget()
+    // Add other targets as needed (jvm, iosArm64, etc.)
+
+    sourceSets {
+        commonMain.dependencies {
+            implementation(libs.ktor.client.core)
+            implementation(libs.ktor.client.content.negotiation)
+            implementation(libs.ktor.serialization.kotlinx.json)
+            implementation(libs.sqldelight.runtime)
+            implementation(libs.koin.core)
+            implementation(libs.kotlinx.coroutines.core)
+            implementation(libs.kotlinx.serialization.json)
+        }
+        androidMain.dependencies {
+            implementation(libs.ktor.client.okhttp)
+            implementation(libs.sqldelight.android.driver)
+            implementation(libs.koin.android)
+        }
+    }
+}
+```
+
+## Compose Multiplatform (for shared UI)
+
+Use when you want to share UI across Android + Desktop + Web:
+
+```kotlin
+// commonMain — shared composable
+@Composable
+fun HomeScreenContent(
+    state: HomeUiState,
+    onRetry: () -> Unit
+) {
+    when (state) {
+        is HomeUiState.Loading -> CircularProgressIndicator()
+        is HomeUiState.Success -> ItemList(state.items)
+        is HomeUiState.Error -> ErrorView(state.message, onRetry)
+    }
+}
+
+// androidApp — wraps with Android ViewModel
+@Composable
+fun HomeScreen(viewModel: HomeViewModel = koinViewModel()) {
+    val state by viewModel.uiState.collectAsStateWithLifecycle()
+    HomeScreenContent(state, onRetry = viewModel::refresh)
+}
+```

package/bundled-skills/android-dev/references/native-android.md

@@ -0,0 +1,239 @@
+# Native Android Reference (Kotlin + Jetpack Compose)
+
+## Project Structure
+
+```
+app/
+├── src/
+│   ├── main/
+│   │   ├── AndroidManifest.xml
+│   │   ├── java/com.example.app/
+│   │   │   ├── MyApp.kt                     # Application class, Hilt entry point
+│   │   │   ├── MainActivity.kt              # Single activity, NavHost host
+│   │   │   ├── ui/
+│   │   │   │   ├── theme/                   # MaterialTheme, Color, Type, Shape
+│   │   │   │   ├── components/              # Shared design system composables
+│   │   │   │   └── feature/
+│   │   │   │       ├── home/
+│   │   │   │       │   ├── HomeScreen.kt
+│   │   │   │       │   ├── HomeViewModel.kt
+│   │   │   │       │   └── HomeUiState.kt
+│   │   │   ├── domain/
+│   │   │   │   ├── model/                   # Domain models (pure Kotlin, no Android deps)
+│   │   │   │   ├── repository/              # Interfaces only
+│   │   │   │   └── usecase/                 # One class per use case
+│   │   │   ├── data/
+│   │   │   │   ├── remote/                  # Retrofit services, DTOs, mappers
+│   │   │   │   ├── local/                   # Room DB, DAOs, entities
+│   │   │   │   └── repository/              # Repository implementations
+│   │   │   └── di/                          # Hilt modules
+│   └── test/                                # Unit tests
+│   └── androidTest/                         # Instrumented tests
+├── build.gradle.kts
+└── proguard-rules.pro
+```
+
+## ViewModel Pattern
+
+```kotlin
+// UiState — sealed class for exhaustive when()
+sealed class HomeUiState {
+    object Loading : HomeUiState()
+    data class Success(val items: List<Item>) : HomeUiState()
+    data class Error(val message: String) : HomeUiState()
+}
+
+// UiEvent — one-shot events (navigation, snackbars)
+sealed class HomeUiEvent {
+    data class NavigateTo(val route: String) : HomeUiEvent()
+    data class ShowSnackbar(val message: String) : HomeUiEvent()
+}
+
+@HiltViewModel
+class HomeViewModel @Inject constructor(
+    private val getItemsUseCase: GetItemsUseCase
+) : ViewModel() {
+
+    private val _uiState = MutableStateFlow<HomeUiState>(HomeUiState.Loading)
+    val uiState: StateFlow<HomeUiState> = _uiState.asStateFlow()
+
+    private val _uiEvent = Channel<HomeUiEvent>()
+    val uiEvent = _uiEvent.receiveAsFlow()
+
+    init { loadItems() }
+
+    fun loadItems() {
+        viewModelScope.launch {
+            _uiState.value = HomeUiState.Loading
+            getItemsUseCase()
+                .onSuccess { _uiState.value = HomeUiState.Success(it) }
+                .onFailure { _uiState.value = HomeUiState.Error(it.message ?: "Unknown error") }
+        }
+    }
+}
+```
+
+## Repository Pattern
+
+```kotlin
+// Interface in domain layer
+interface ItemRepository {
+    fun observeItems(): Flow<List<Item>>
+    suspend fun refreshItems(): Result<Unit>
+    suspend fun getItemById(id: String): Result<Item>
+}
+
+// Implementation in data layer
+class ItemRepositoryImpl @Inject constructor(
+    private val remoteSource: ItemRemoteDataSource,
+    private val localSource: ItemLocalDataSource,
+    private val mapper: ItemMapper
+) : ItemRepository {
+
+    override fun observeItems(): Flow<List<Item>> =
+        localSource.observeAll().map { mapper.toDomain(it) }
+
+    override suspend fun refreshItems(): Result<Unit> = runCatching {
+        val dto = remoteSource.fetchItems()
+        localSource.insertAll(mapper.toEntity(dto))
+    }
+
+    override suspend fun getItemById(id: String): Result<Item> = runCatching {
+        // Example implementation fetching from local cache
+        val entity = localSource.getById(id) ?: throw Exception("Item not found")
+        mapper.toDomain(entity)
+    }
+}
+```
+
+## Compose Screen
+
+```kotlin
+@Composable
+fun HomeScreen(
+    viewModel: HomeViewModel = hiltViewModel(),
+    onNavigate: (String) -> Unit
+) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    val snackbarHostState = remember { SnackbarHostState() }
+
+    // One-shot event handling
+    LaunchedEffect(Unit) {
+        viewModel.uiEvent.collect { event ->
+            when (event) {
+                is HomeUiEvent.NavigateTo -> onNavigate(event.route)
+                is HomeUiEvent.ShowSnackbar -> snackbarHostState.showSnackbar(event.message)
+            }
+        }
+    }
+
+    Scaffold(snackbarHost = { SnackbarHost(snackbarHostState) }) { padding ->
+        when (val state = uiState) {
+            is HomeUiState.Loading -> LoadingContent()
+            is HomeUiState.Success -> HomeContent(state.items, Modifier.padding(padding))
+            is HomeUiState.Error -> ErrorContent(state.message, onRetry = viewModel::loadItems)
+        }
+    }
+}
+```
+
+## Room Database
+
+```kotlin
+@Entity(tableName = "items")
+data class ItemEntity(
+    @PrimaryKey val id: String,
+    val title: String,
+    val updatedAt: Long = System.currentTimeMillis()
+)
+
+@Dao
+interface ItemDao {
+    @Query("SELECT * FROM items ORDER BY updatedAt DESC")
+    fun observeAll(): Flow<List<ItemEntity>>
+
+    @Upsert
+    suspend fun upsertAll(items: List<ItemEntity>)
+
+    @Query("DELETE FROM items")
+    suspend fun deleteAll()
+}
+
+@Database(entities = [ItemEntity::class], version = 1, exportSchema = true)
+abstract class AppDatabase : RoomDatabase() {
+    abstract fun itemDao(): ItemDao
+}
+```
+
+## Hilt DI Setup
+
+```kotlin
+@Module
+@InstallIn(SingletonComponent::class)
+object NetworkModule {
+    @Provides @Singleton
+    fun provideRetrofit(): Retrofit = Retrofit.Builder()
+        .baseUrl(BuildConfig.API_BASE_URL)
+        .addConverterFactory(GsonConverterFactory.create())
+        .client(buildOkHttpClient())
+        .build()
+}
+
+@Module
+@InstallIn(SingletonComponent::class)
+abstract class RepositoryModule {
+    @Binds @Singleton
+    abstract fun bindItemRepository(impl: ItemRepositoryImpl): ItemRepository
+}
+```
+
+## Key Dependencies (libs.versions.toml)
+
+```toml
+[versions]
+kotlin = "2.0.0"
+compose-bom = "2024.06.00"
+hilt = "2.51"
+room = "2.6.1"
+retrofit = "2.11.0"
+coroutines = "1.8.1"
+lifecycle = "2.8.2"
+
+[libraries]
+compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "compose-bom" }
+compose-ui = { group = "androidx.compose.ui", name = "ui" }
+compose-material3 = { group = "androidx.compose.material3", name = "material3" }
+hilt-android = { group = "com.google.dagger", name = "hilt-android", version.ref = "hilt" }
+hilt-compiler = { group = "com.google.dagger", name = "hilt-android-compiler", version.ref = "hilt" }
+room-runtime = { group = "androidx.room", name = "room-runtime", version.ref = "room" }
+room-ktx = { group = "androidx.room", name = "room-ktx", version.ref = "room" }
+room-compiler = { group = "androidx.room", name = "room-compiler", version.ref = "room" }
+retrofit = { group = "com.squareup.retrofit2", name = "retrofit", version.ref = "retrofit" }
+```
+
+## Testing Setup
+
+```kotlin
+// ViewModel unit test
+@OptIn(ExperimentalCoroutinesApi::class)
+class HomeViewModelTest {
+    @get:Rule val mainDispatcherRule = MainDispatcherRule()
+
+    private val getItemsUseCase = mockk<GetItemsUseCase>()
+    private lateinit var viewModel: HomeViewModel
+
+    @BeforeEach
+    fun setup() { viewModel = HomeViewModel(getItemsUseCase) }
+
+    @Test
+    fun `loadItems emits Success when use case succeeds`() = runTest {
+        val items = listOf(Item("1", "Test"))
+        coEvery { getItemsUseCase() } returns Result.success(items)
+
+        viewModel.uiState.test {
+            skipItems(1) // Loading
+            assertThat(awaitItem()).isEqualTo(HomeUiState.Success(items))
+        }
+    }
+}
+```

package/bundled-skills/android-dev/references/react-native.md

@@ -0,0 +1,242 @@
+# React Native Reference (TypeScript)
+
+## Project Structure
+
+```
+src/
+├── app/
+│   ├── App.tsx                  # Root component, providers
+│   ├── navigation/              # React Navigation stacks + types
+│   └── store/                   # RTK store setup
+├── features/
+│   └── home/
+│       ├── api/                 # RTK Query endpoints
+│       ├── components/          # Screen-specific components
+│       ├── hooks/               # Feature-level custom hooks
+│       ├── screens/             # Screen components
+│       ├── store/               # Zustand slice or RTK slice
+│       └── types.ts             # Feature types
+├── shared/
+│   ├── components/              # Design system components
+│   ├── hooks/                   # Shared hooks
+│   ├── theme/                   # Colors, typography, spacing constants
+│   └── utils/                   # Utilities
+└── services/
+    ├── api/                     # Axios/fetch client + interceptors
+    └── storage/                 # MMKV wrapper
+```
+
+## Navigation Setup (React Navigation v7)
+
+```typescript
+export type RootStackParamList = {
+  Auth: undefined;
+  Home: undefined;
+  Detail: { id: string };
+  Settings: undefined;
+};
+
+export type RootStackScreenProps<T extends keyof RootStackParamList> =
+  NativeStackScreenProps<RootStackParamList, T>;
+
+const Stack = createNativeStackNavigator<RootStackParamList>();
+
+export const RootNavigator = () => {
+  const isLoggedIn = useAuthStore((s) => s.isLoggedIn);
+
+  return (
+    <Stack.Navigator screenOptions={{ headerShown: false }}>
+      {isLoggedIn ? (
+        <>
+          <Stack.Screen name="Home" component={HomeScreen} />
+          <Stack.Screen name="Detail" component={DetailScreen} />
+        </>
+      ) : (
+        <Stack.Screen name="Auth" component={AuthScreen} />
+      )}
+    </Stack.Navigator>
+  );
+};
+```
+
+## State Management (Zustand + React Query)
+
+```typescript
+// Client state — Zustand
+interface AuthState {
+  token: string | null;
+  isLoggedIn: boolean;
+  setToken: (token: string) => void;
+  logout: () => void;
+}
+
+export const useAuthStore = create<AuthState>()(
+  persist(
+    (set) => ({
+      token: null,
+      isLoggedIn: false,
+      setToken: (token) => set({ token, isLoggedIn: true }),
+      logout: () => set({ token: null, isLoggedIn: false }),
+    }),
+    { name: 'auth-storage', storage: createJSONStorage(() => mmkvStorage) }
+  )
+);
+
+// Server state — React Query
+export const useItems = () =>
+  useQuery({
+    queryKey: ['items'],
+    queryFn: itemsApi.getAll,
+    staleTime: 5 * 60 * 1000, // 5 minutes
+  });
+
+export const useRefreshItems = () =>
+  useMutation({
+    mutationFn: itemsApi.refresh,
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: ['items'] }),
+  });
+```
+
+## Screen Pattern
+
+```typescript
+type HomeScreenProps = RootStackScreenProps<'Home'>;
+
+export const HomeScreen: FC<HomeScreenProps> = ({ navigation }) => {
+  const { data: items, isLoading, isError, refetch } = useItems();
+
+  if (isLoading) return <LoadingView />;
+  if (isError) return <ErrorView onRetry={refetch} />;
+
+  return (
+    <SafeAreaView style={styles.container}>
+      <FlatList
+        data={items}
+        keyExtractor={(item) => item.id}
+        renderItem={({ item }) => (
+          <ItemCard
+            item={item}
+            onPress={() => navigation.navigate('Detail', { id: item.id })}
+          />
+        )}
+        ListEmptyComponent={<EmptyView />}
+        refreshControl={
+          <RefreshControl refreshing={isLoading} onRefresh={refetch} />
+        }
+      />
+    </SafeAreaView>
+  );
+};
+```
+
+## API Client (Axios with interceptors)
+
+```typescript
+const apiClient = axios.create({
+  baseURL: Config.API_BASE_URL,
+  timeout: 10_000,
+  headers: { 'Content-Type': 'application/json' },
+});
+
+// Auth token injection
+apiClient.interceptors.request.use((config) => {
+  const token = useAuthStore.getState().token;
+  if (token) config.headers.Authorization = `Bearer ${token}`;
+  return config;
+});
+
+// Token refresh on 401
+apiClient.interceptors.response.use(
+  (res) => res,
+  async (error: AxiosError) => {
+    if (error.response?.status === 401) {
+      const newToken = await refreshToken();
+      if (newToken) {
+        useAuthStore.getState().setToken(newToken);
+        return apiClient(error.config!);
+      }
+      useAuthStore.getState().logout();
+    }
+    return Promise.reject(error);
+  }
+);
+```
+
+## API Response Validation (Zod)
+
+```typescript
+const ItemSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.string().optional(),
+  createdAt: z.string().datetime(),
+});
+
+const ItemsResponseSchema = z.array(ItemSchema);
+type Item = z.infer<typeof ItemSchema>;
+
+const getItems = async (): Promise<Item[]> => {
+  const { data } = await apiClient.get('/items');
+  return ItemsResponseSchema.parse(data); // throws ZodError on invalid shape
+};
+```
+
+## Key Dependencies
+
+```json
+{
+  "dependencies": {
+    "react-native": "0.74.x",
+    "@react-navigation/native": "^7.0.0",
+    "@react-navigation/native-stack": "^7.0.0",
+    "@tanstack/react-query": "^5.45.0",
+    "zustand": "^4.5.4",
+    "axios": "^1.7.2",
+    "zod": "^3.23.8",
+    "react-native-mmkv": "^2.12.2",
+    "react-native-safe-area-context": "^4.10.1",
+    "react-native-screens": "^3.32.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.5",
+    "@testing-library/react-native": "^12.5.1",
+    "msw": "^2.3.1",
+    "jest": "^29.7.0"
+  }
+}
+```
+
+## New Architecture (Bridgeless) Notes
+- Enable New Architecture in `android/gradle.properties`: `newArchEnabled=true`
+- Use TurboModules for native modules; avoid legacy NativeModules API
+- Use Fabric for custom native views
+- Test with Hermes JS engine always enabled
+
+## Performance Tips
+- Use `useCallback` + `memo` on `renderItem` / list item components
+- `FlatList` `windowSize`, `initialNumToRender`, `maxToRenderPerBatch` tuned
+- Avoid anonymous inline functions in JSX
+- `InteractionManager.runAfterInteractions` for heavy post-navigation work
+- `react-native-reanimated` for 60fps animations (runs on UI thread)
+
+## Testing
+
+```typescript
+describe('HomeScreen', () => {
+  it('shows items when query succeeds', async () => {
+    server.use(
+      http.get(`${API_URL}/items`, () =>
+        HttpResponse.json([{ id: '1', title: 'Test Item' }])
+      )
+    );
+
+    const { getByText } = render(
+      <QueryClientProvider client={testQueryClient}>
+        <HomeScreen navigation={mockNavigation} route={mockRoute} />
+      </QueryClientProvider>
+    );
+
+    expect(await findByText('Test Item')).toBeTruthy();
+  });
+});
+```

package/bundled-skills/docs/integrations/jetski-cortex.md

@@ -1,9 +1,9 @@
 ---
 title: Jetski/Cortex + Gemini Integration Guide
-description: "Use antigravity-awesome-skills with Jetski/Cortex without hitting context-window overflow with 1,525+ skills."
+description: "Use antigravity-awesome-skills with Jetski/Cortex without hitting context-window overflow with 1,527+ skills."
 ---
 
-# Jetski/Cortex + Gemini: safe integration with 1,525+ skills
+# Jetski/Cortex + Gemini: safe integration with 1,527+ skills
 
 This guide shows how to integrate the `antigravity-awesome-skills` repository with an agent based on **Jetski/Cortex + Gemini** (or similar frameworks) **without exceeding the model context window**.
 
@@ -23,7 +23,7 @@ Never do:
 - concatenate all `SKILL.md` content into a single system prompt;
 - re-inject the entire library for **every** request.
 
-With 1,525+ skills, this approach fills the context window before user messages are even added, causing truncation.
+With 1,527+ skills, this approach fills the context window before user messages are even added, causing truncation.
 
 ---