@backendkit-labs/agent-core 0.14.0

package/dist/skills/builtins/kotlin-pack.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KOTLIN_PACK_SKILLS = void 0;
+/**
+ * Kotlin / Android skill pack (@bk-kotlin).
+ * Activated for projects with build.gradle containing kotlin plugin,
+ * detected via 'kotlin' stack (same indicator as java but differentiated
+ * by triggers and stack field).
+ */
+exports.KOTLIN_PACK_SKILLS = [
+    {
+        name: 'kotlin-coroutines',
+        version: '1.0.0',
+        description: 'Kotlin coroutines: suspend functions, Flow, coroutine scopes and error handling',
+        scope: 'pack',
+        pack: '@bk-kotlin',
+        language: ['kotlin'],
+        triggers: [
+            'coroutine', 'coroutines', 'suspend', 'flow', 'stateflow', 'sharedflow',
+            'async', 'launch', 'withcontext', 'dispatcher', 'scope', 'job',
+            'concurrencia', 'concurrency', 'asincrono', 'asynchronous',
+        ],
+        systemPromptAddition: `## Kotlin Coroutines
+
+### Suspend functions — siempre en el scope correcto
+\`\`\`kotlin
+// Repository
+suspend fun findById(id: String): User? = withContext(Dispatchers.IO) {
+    db.userDao().findById(id)
+}
+
+// ViewModel
+viewModelScope.launch {
+    _uiState.value = UiState.Loading
+    runCatching { repository.findById(id) }
+        .onSuccess { _uiState.value = UiState.Success(it) }
+        .onFailure { _uiState.value = UiState.Error(it.message) }
+}
+\`\`\`
+
+### Flow para streams de datos
+\`\`\`kotlin
+// Repository — expone Flow
+fun observeUsers(): Flow<List<User>> = db.userDao().observeAll()
+
+// ViewModel — convierte a StateFlow
+val users: StateFlow<List<User>> = repository.observeUsers()
+    .stateIn(
+        scope = viewModelScope,
+        started = SharingStarted.WhileSubscribed(5_000),
+        initialValue = emptyList(),
+    )
+\`\`\`
+
+### Manejo de errores en Flow
+\`\`\`kotlin
+repository.observeUsers()
+    .catch { emit(emptyList()) }      // recupera de errores
+    .collect { users -> ... }
+\`\`\`
+
+### Dispatchers
+| Dispatcher | Uso |
+|---|---|
+| \`Dispatchers.Main\` | UI, actualizar estado |
+| \`Dispatchers.IO\` | Red, disco, base de datos |
+| \`Dispatchers.Default\` | CPU-intensivo (sort, parse) |
+
+### Reglas
+- Usa \`viewModelScope\` en ViewModels — se cancela automáticamente al limpiar
+- Usa \`lifecycleScope\` en Activities/Fragments — respeta el lifecycle
+- Nunca uses \`GlobalScope\` — no se cancela automáticamente
+- Prefiere \`StateFlow\` sobre \`LiveData\` en código nuevo`,
+    },
+    {
+        name: 'compose-patterns',
+        version: '1.0.0',
+        description: 'Jetpack Compose: composable functions, state hoisting, side effects',
+        scope: 'pack',
+        pack: '@bk-kotlin',
+        language: ['kotlin'],
+        triggers: [
+            'compose', 'composable', 'jetpack compose', 'ui', 'pantalla', 'screen',
+            'remember', 'state', 'recomposition', 'launchedeffect', 'sideeffect',
+            'column', 'row', 'box', 'modifier', 'material', 'scaffold',
+        ],
+        systemPromptAddition: `## Jetpack Compose
+
+### State hoisting — separa lógica de presentación
+\`\`\`kotlin
+// Stateless (reutilizable, testeable)
+@Composable
+fun UserCard(user: User, onDelete: () -> Unit, modifier: Modifier = Modifier) {
+    Card(modifier = modifier) {
+        Text(user.name)
+        IconButton(onClick = onDelete) { Icon(Icons.Default.Delete, null) }
+    }
+}
+
+// Stateful (pantalla completa, conectada al ViewModel)
+@Composable
+fun UserScreen(viewModel: UserViewModel = hiltViewModel()) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+
+    when (val state = uiState) {
+        is UiState.Loading -> CircularProgressIndicator()
+        is UiState.Success -> UserCard(state.user, onDelete = viewModel::delete)
+        is UiState.Error   -> Text("Error: \${state.message}")
+    }
+}
+\`\`\`
+
+### Side effects
+\`\`\`kotlin
+// LaunchedEffect — coroutine atada al lifecycle del composable
+LaunchedEffect(userId) {   // se relanza si userId cambia
+    viewModel.loadUser(userId)
+}
+
+// DisposableEffect — recursos que necesitan cleanup
+DisposableEffect(Unit) {
+    val callback = registerCallback()
+    onDispose { callback.unregister() }
+}
+\`\`\`
+
+### Modifier — siempre como último parámetro con default
+\`\`\`kotlin
+@Composable
+fun MyComponent(
+    title: String,
+    modifier: Modifier = Modifier,   // convención de Compose
+) { ... }
+\`\`\`
+
+### Reglas
+- Funciones composable en PascalCase, sin retorno de valor
+- Hoist el state tan arriba como sea necesario — no más
+- Evita lógica de negocio en composables — solo UI
+- Usa \`collectAsStateWithLifecycle()\` (no \`collectAsState()\`) para respetar el lifecycle`,
+    },
+    {
+        name: 'android-architecture',
+        version: '1.0.0',
+        description: 'Android Clean Architecture: ViewModel + StateFlow + Repository pattern + Hilt',
+        scope: 'pack',
+        pack: '@bk-kotlin',
+        language: ['kotlin'],
+        triggers: [
+            'viewmodel', 'repository', 'usecase', 'use case', 'arquitectura',
+            'architecture', 'hilt', 'dependency injection', 'inyeccion', 'clean',
+            'room', 'retrofit', 'navigation', 'module',
+        ],
+        systemPromptAddition: `## Android Clean Architecture
+
+### Capas
+\`\`\`
+UI (Composables)
+    ↓ observe StateFlow
+ViewModel (viewModelScope)
+    ↓ suspend fun / Flow
+Repository (interface en domain, impl en data)
+    ↓
+DataSource (Room DAO / Retrofit API)
+\`\`\`
+
+### ViewModel con StateFlow
+\`\`\`kotlin
+@HiltViewModel
+class UserViewModel @Inject constructor(
+    private val userRepository: UserRepository,
+) : ViewModel() {
+
+    private val _uiState = MutableStateFlow<UiState<User>>(UiState.Loading)
+    val uiState: StateFlow<UiState<User>> = _uiState.asStateFlow()
+
+    fun loadUser(id: String) {
+        viewModelScope.launch {
+            _uiState.value = UiState.Loading
+            userRepository.findById(id)
+                .onSuccess { _uiState.value = UiState.Success(it) }
+                .onFailure { _uiState.value = UiState.Error(it.message ?: "Unknown error") }
+        }
+    }
+}
+
+sealed class UiState<out T> {
+    data object Loading : UiState<Nothing>()
+    data class Success<T>(val data: T) : UiState<T>()
+    data class Error(val message: String) : UiState<Nothing>()
+}
+\`\`\`
+
+### Repository
+\`\`\`kotlin
+// Interface en domain (sin dependencias Android)
+interface UserRepository {
+    suspend fun findById(id: String): Result<User>
+    fun observeAll(): Flow<List<User>>
+}
+
+// Implementación en data
+class UserRepositoryImpl @Inject constructor(
+    private val dao: UserDao,
+    private val api: UserApi,
+) : UserRepository {
+    override suspend fun findById(id: String): Result<User> = runCatching {
+        dao.findById(id) ?: api.getUser(id).also { dao.insert(it) }
+    }
+}
+\`\`\`
+
+### Hilt modules
+\`\`\`kotlin
+@Module
+@InstallIn(SingletonComponent::class)
+abstract class RepositoryModule {
+    @Binds @Singleton
+    abstract fun bindUserRepo(impl: UserRepositoryImpl): UserRepository
+}
+\`\`\`
+
+### Reglas
+- ViewModels no importan clases Android (Context, Activity) — solo lógica
+- Repository oculta la fuente de datos (Room vs API) — el ViewModel no sabe de dónde vienen los datos
+- Usa \`Result<T>\` para operaciones que pueden fallar
+- Room: NUNCA accedas a la base de datos desde el main thread`,
+    },
+    {
+        name: 'kotlin-testing',
+        version: '1.0.0',
+        description: 'Kotlin testing: JUnit 5, MockK, Turbine for Flow, coroutine test utilities',
+        scope: 'pack',
+        pack: '@bk-kotlin',
+        language: ['kotlin'],
+        triggers: [
+            'test', 'tests', 'testing', 'prueba', 'mockk', 'mock', 'turbine',
+            'coroutinetest', 'junit', 'coevery', 'coassert', 'coverage',
+        ],
+        systemPromptAddition: `## Kotlin Testing
+
+### Test de ViewModel con Turbine (Flow)
+\`\`\`kotlin
+@OptIn(ExperimentalCoroutinesApi::class)
+class UserViewModelTest {
+    @get:Rule val mainRule = MainCoroutineRule() // reemplaza Dispatchers.Main
+
+    private val repository: UserRepository = mockk()
+    private lateinit var viewModel: UserViewModel
+
+    @BeforeEach fun setup() { viewModel = UserViewModel(repository) }
+
+    @Test fun \`loadUser emits Success when repository returns user\`() = runTest {
+        val user = User("1", "ana@example.com")
+        coEvery { repository.findById("1") } returns Result.success(user)
+
+        viewModel.uiState.test {
+            viewModel.loadUser("1")
+            assertThat(awaitItem()).isInstanceOf(UiState.Loading::class.java)
+            assertThat(awaitItem()).isEqualTo(UiState.Success(user))
+            cancelAndIgnoreRemainingEvents()
+        }
+    }
+}
+\`\`\`
+
+### MainCoroutineRule (para tests con Dispatchers.Main)
+\`\`\`kotlin
+class MainCoroutineRule : TestWatcher() {
+    val testDispatcher = UnconfinedTestDispatcher()
+    override fun starting(d: Description) { Dispatchers.setMain(testDispatcher) }
+    override fun finished(d: Description) { Dispatchers.resetMain() }
+}
+\`\`\`
+
+### Mock con MockK
+\`\`\`kotlin
+val repo: UserRepository = mockk()
+coEvery { repo.findById(any()) } returns Result.success(user) // suspend fun
+every { repo.observeAll() } returns flowOf(listOf(user))      // Flow
+
+coVerify { repo.findById("1") }
+\`\`\`
+
+### Reglas
+- Usa \`runTest\` para tests de coroutines — maneja automáticamente los dispatchers de test
+- Usa Turbine para testear Flow (\`flow.test { ... }\`)
+- Usa MockK (no Mockito) para mocks en Kotlin — soporte nativo de suspend/coroutines
+- Nombra los tests con backticks: \`\`fun \`loads user when id is valid\`()\`\``,
+    },
+];
+//# sourceMappingURL=kotlin-pack.js.map

package/dist/skills/builtins/kotlin-pack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kotlin-pack.js","sourceRoot":"","sources":["../../../src/skills/builtins/kotlin-pack.ts"],"names":[],"mappings":";;;AAEA;;;;;GAKG;AACU,QAAA,kBAAkB,GAAY;IACvC;QACI,IAAI,EAAE,mBAAmB;QACzB,OAAO,EAAE,OAAO;QAChB,WAAW,EAAE,iFAAiF;QAC9F,KAAK,EAAE,MAAM;QACb,IAAI,EAAE,YAAY;QAClB,QAAQ,EAAE,CAAC,QAAQ,CAAC;QACpB,QAAQ,EAAE;YACN,WAAW,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,YAAY;YACvE,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,YAAY,EAAE,OAAO,EAAE,KAAK;YAC9D,cAAc,EAAE,aAAa,EAAE,WAAW,EAAE,cAAc;SAC7D;QACD,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4DAkD8B;KACvD;IACD;QACI,IAAI,EAAE,kBAAkB;QACxB,OAAO,EAAE,OAAO;QAChB,WAAW,EAAE,qEAAqE;QAClF,KAAK,EAAE,MAAM;QACb,IAAI,EAAE,YAAY;QAClB,QAAQ,EAAE,CAAC,QAAQ,CAAC;QACpB,QAAQ,EAAE;YACN,SAAS,EAAE,YAAY,EAAE,iBAAiB,EAAE,IAAI,EAAE,UAAU,EAAE,QAAQ;YACtE,UAAU,EAAE,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,YAAY;YACpE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU;SAC7D;QACD,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6FAqD+D;KACxF;IACD;QACI,IAAI,EAAE,sBAAsB;QAC5B,OAAO,EAAE,OAAO;QAChB,WAAW,EAAE,+EAA+E;QAC5F,KAAK,EAAE,MAAM;QACb,IAAI,EAAE,YAAY;QAClB,QAAQ,EAAE,CAAC,QAAQ,CAAC;QACpB,QAAQ,EAAE;YACN,WAAW,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,cAAc;YAChE,cAAc,EAAE,MAAM,EAAE,sBAAsB,EAAE,WAAW,EAAE,OAAO;YACpE,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,QAAQ;SAC7C;QACD,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DAyEgC;KACzD;IACD;QACI,IAAI,EAAE,gBAAgB;QACtB,OAAO,EAAE,OAAO;QAChB,WAAW,EAAE,4EAA4E;QACzF,KAAK,EAAE,MAAM;QACb,IAAI,EAAE,YAAY;QAClB,QAAQ,EAAE,CAAC,QAAQ,CAAC;QACpB,QAAQ,EAAE;YACN,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS;YAChE,eAAe,EAAE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU;SAC9D;QACD,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gFAiDkD;KAC3E;CACJ,CAAC"}

package/dist/skills/builtins/node-pack.d.ts

@@ -0,0 +1,7 @@
+import type { Skill } from '../types';
+/**
+ * Node.js / TypeScript skill pack (@bk-node).
+ * Only activated for projects with package.json or tsconfig.json.
+ */
+export declare const NODE_PACK_SKILLS: Skill[];
+//# sourceMappingURL=node-pack.d.ts.map

package/dist/skills/builtins/node-pack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-pack.d.ts","sourceRoot":"","sources":["../../../src/skills/builtins/node-pack.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEtC;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,KAAK,EAquBnC,CAAC"}