@backendkit-labs/agent-coding 0.14.0

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

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GO_PACK_SKILLS = void 0;
+/**
+ * Go skill pack (@bk-go).
+ * Activated for projects with go.mod.
+ */
+exports.GO_PACK_SKILLS = [
+    {
+        name: 'go-error-handling',
+        version: '1.0.0',
+        description: 'Idiomatic Go error handling: wrapping, sentinel errors, errors.Is/As',
+        scope: 'pack',
+        pack: '@bk-go',
+        language: ['go'],
+        triggers: [
+            'error', 'errors', 'manejo de errores', 'error handling',
+            'fmt.Errorf', 'errors.Is', 'errors.As', 'sentinel', 'wrap',
+        ],
+        systemPromptAddition: `## Go Error Handling
+
+NUNCA ignores errores. Siempre verifica el valor de retorno de error.
+
+### Wrapping (conserva la cadena de contexto)
+\`\`\`go
+if err != nil {
+    return fmt.Errorf("userService.FindByID %q: %w", id, err)
+}
+\`\`\`
+
+### Sentinel errors (errores de dominio)
+\`\`\`go
+var (
+    ErrNotFound   = errors.New("not found")
+    ErrConflict   = errors.New("conflict")
+    ErrValidation = errors.New("validation failed")
+)
+
+// Verificar en el caller:
+if errors.Is(err, ErrNotFound) { ... }
+\`\`\`
+
+### Errores con datos (implementar error interface)
+\`\`\`go
+type ValidationError struct {
+    Field   string
+    Message string
+}
+func (e *ValidationError) Error() string {
+    return fmt.Sprintf("validation: %s — %s", e.Field, e.Message)
+}
+
+// Extraer en el caller:
+var ve *ValidationError
+if errors.As(err, &ve) { ... }
+\`\`\`
+
+### Reglas
+- Usa \`%w\` para wrapping (permite errors.Is/As upstream)
+- Usa \`%v\` solo para logging, nunca para propagar
+- Los mensajes de error en minúscula, sin punto final
+- No uses \`panic\` para errores de negocio — solo para invariantes rotos`,
+    },
+    {
+        name: 'go-concurrency',
+        version: '1.0.0',
+        description: 'Goroutines, channels, context propagation and sync primitives',
+        scope: 'pack',
+        pack: '@bk-go',
+        language: ['go'],
+        triggers: [
+            'goroutine', 'channel', 'chan', 'concurrencia', 'concurrency',
+            'context', 'ctx', 'sync', 'mutex', 'waitgroup', 'select', 'timeout',
+        ],
+        systemPromptAddition: `## Go Concurrency
+
+### Context — siempre el primer parámetro
+\`\`\`go
+func (s *UserService) FindByID(ctx context.Context, id string) (*User, error) {
+    // Propaga ctx a toda operación I/O
+    return s.repo.FindByID(ctx, id)
+}
+\`\`\`
+
+### Timeout y cancelación
+\`\`\`go
+ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
+defer cancel()
+\`\`\`
+
+### Goroutines: siempre controla el ciclo de vida
+\`\`\`go
+var wg sync.WaitGroup
+errCh := make(chan error, len(items)) // buffered para evitar goroutine leak
+
+for _, item := range items {
+    wg.Add(1)
+    go func(item Item) {
+        defer wg.Done()
+        if err := process(ctx, item); err != nil {
+            errCh <- err
+        }
+    }(item)
+}
+
+wg.Wait()
+close(errCh)
+for err := range errCh { ... }
+\`\`\`
+
+### Select con timeout
+\`\`\`go
+select {
+case result := <-resultCh:
+    return result, nil
+case <-ctx.Done():
+    return nil, ctx.Err()
+}
+\`\`\`
+
+### Reglas
+- Nunca lances una goroutine sin controlar su ciclo de vida
+- Usa canales buffered cuando el producer no debe bloquearse
+- \`sync.Mutex\` para estado compartido simple; \`sync.RWMutex\` si hay muchas lecturas
+- Nunca copies un Mutex — pásalo siempre por puntero`,
+    },
+    {
+        name: 'go-http-server',
+        version: '1.0.0',
+        description: 'HTTP server patterns: handlers, middleware, routing with net/http or chi',
+        scope: 'pack',
+        pack: '@bk-go',
+        language: ['go'],
+        triggers: [
+            'http', 'handler', 'middleware', 'router', 'endpoint', 'api rest',
+            'net/http', 'chi', 'gin', 'echo', 'mux', 'servidor', 'server',
+        ],
+        systemPromptAddition: `## Go HTTP Server
+
+### Handler con dependencias inyectadas
+\`\`\`go
+type UserHandler struct {
+    service UserService
+}
+
+func NewUserHandler(service UserService) *UserHandler {
+    return &UserHandler{service: service}
+}
+
+func (h *UserHandler) GetByID(w http.ResponseWriter, r *http.Request) {
+    id := chi.URLParam(r, "id") // o r.PathValue("id") en Go 1.22+
+    user, err := h.service.FindByID(r.Context(), id)
+    if err != nil {
+        writeError(w, err)
+        return
+    }
+    writeJSON(w, http.StatusOK, user)
+}
+\`\`\`
+
+### Middleware (adaptar al router usado)
+\`\`\`go
+func LoggingMiddleware(next http.Handler) http.Handler {
+    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+        start := time.Now()
+        next.ServeHTTP(w, r)
+        slog.Info("request", "method", r.Method, "path", r.URL.Path,
+            "elapsed", time.Since(start))
+    })
+}
+\`\`\`
+
+### Helpers JSON
+\`\`\`go
+func writeJSON(w http.ResponseWriter, status int, v any) {
+    w.Header().Set("Content-Type", "application/json")
+    w.WriteHeader(status)
+    json.NewEncoder(w).Encode(v)
+}
+
+func writeError(w http.ResponseWriter, err error) {
+    switch {
+    case errors.Is(err, ErrNotFound):
+        writeJSON(w, http.StatusNotFound, map[string]string{"error": err.Error()})
+    case errors.Is(err, ErrValidation):
+        writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+    default:
+        writeJSON(w, http.StatusInternalServerError, map[string]string{"error": "internal server error"})
+    }
+}
+\`\`\`
+
+### Reglas
+- Siempre propaga \`r.Context()\` a las llamadas de servicio
+- Nunca escribas al ResponseWriter después de llamar a otro handler
+- Usa \`slog\` (stdlib Go 1.21+) para logging estructurado
+- Valida y deserializa el body antes de llamar al servicio`,
+    },
+    {
+        name: 'go-testing',
+        version: '1.0.0',
+        description: 'Table-driven tests, testify, interfaces for mocking',
+        scope: 'pack',
+        pack: '@bk-go',
+        language: ['go'],
+        triggers: [
+            'test', 'tests', 'testing', 'prueba', 'mock', 'testify',
+            'table driven', 'table-driven', 'assert', 'require', 'coverage',
+        ],
+        systemPromptAddition: `## Go Testing
+
+### Table-driven tests (patrón estándar)
+\`\`\`go
+func TestUserService_FindByID(t *testing.T) {
+    tests := []struct {
+        name    string
+        id      string
+        want    *User
+        wantErr error
+    }{
+        {name: "found", id: "1", want: &User{ID: "1"}},
+        {name: "not found", id: "999", wantErr: ErrNotFound},
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            svc := NewUserService(newMockRepo(tt.want, tt.wantErr))
+            got, err := svc.FindByID(context.Background(), tt.id)
+            require.ErrorIs(t, err, tt.wantErr)
+            assert.Equal(t, tt.want, got)
+        })
+    }
+}
+\`\`\`
+
+### Mock via interface (sin frameworks externos)
+\`\`\`go
+type mockUserRepo struct {
+    user *User
+    err  error
+}
+func (m *mockUserRepo) FindByID(_ context.Context, _ string) (*User, error) {
+    return m.user, m.err
+}
+func newMockRepo(u *User, err error) UserRepository { return &mockUserRepo{u, err} }
+\`\`\`
+
+### Subtests y helpers
+\`\`\`go
+func TestIntegration(t *testing.T) {
+    if testing.Short() { t.Skip("skipping integration test") }
+    // ...
+}
+\`\`\`
+
+### Reglas
+- Usa \`require\` (falla inmediato) para precondiciones; \`assert\` para verificaciones
+- Define interfaces pequeñas para mockear dependencias — no dependas de tipos concretos
+- Nombres: \`Test{Tipo}_{Metodo}_{Condicion}\`
+- Usa \`t.Parallel()\` en tests sin estado compartido para acelerar el suite`,
+    },
+];
+//# sourceMappingURL=go-pack.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"go-pack.js","sourceRoot":"","sources":["../../../src/skills/builtins/go-pack.ts"],"names":[],"mappings":";;;AAEA;;;GAGG;AACU,QAAA,cAAc,GAAY;IACnC;QACI,IAAI,EAAE,mBAAmB;QACzB,OAAO,EAAE,OAAO;QAChB,WAAW,EAAE,sEAAsE;QACnF,KAAK,EAAE,MAAM;QACb,IAAI,EAAE,QAAQ;QACd,QAAQ,EAAE,CAAC,IAAI,CAAC;QAChB,QAAQ,EAAE;YACN,OAAO,EAAE,QAAQ,EAAE,mBAAmB,EAAE,gBAAgB;YACxD,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM;SAC7D;QACD,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EA0C8C;KACvE;IACD;QACI,IAAI,EAAE,gBAAgB;QACtB,OAAO,EAAE,OAAO;QAChB,WAAW,EAAE,+DAA+D;QAC5E,KAAK,EAAE,MAAM;QACb,IAAI,EAAE,QAAQ;QACd,QAAQ,EAAE,CAAC,IAAI,CAAC;QAChB,QAAQ,EAAE;YACN,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,cAAc,EAAE,aAAa;YAC7D,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS;SACtE;QACD,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wDAkD0B;KACnD;IACD;QACI,IAAI,EAAE,gBAAgB;QACtB,OAAO,EAAE,OAAO;QAChB,WAAW,EAAE,0EAA0E;QACvF,KAAK,EAAE,MAAM;QACb,IAAI,EAAE,QAAQ;QACd,QAAQ,EAAE,CAAC,IAAI,CAAC;QAChB,QAAQ,EAAE;YACN,MAAM,EAAE,SAAS,EAAE,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU;YACjE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ;SAChE;QACD,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2DA2D6B;KACtD;IACD;QACI,IAAI,EAAE,YAAY;QAClB,OAAO,EAAE,OAAO;QAChB,WAAW,EAAE,qDAAqD;QAClE,KAAK,EAAE,MAAM;QACb,IAAI,EAAE,QAAQ;QACd,QAAQ,EAAE,CAAC,IAAI,CAAC;QAChB,QAAQ,EAAE;YACN,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS;YACvD,cAAc,EAAE,cAAc,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU;SAClE;QACD,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6EAkD+C;KACxE;CACJ,CAAC"}

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

@@ -0,0 +1,7 @@
+import type { Skill } from '@backendkit-labs/agent-core';
+/**
+ * Java / Spring Boot skill pack (@bk-java).
+ * Activated for projects with pom.xml or build.gradle.
+ */
+export declare const JAVA_PACK_SKILLS: Skill[];
+//# sourceMappingURL=java-pack.d.ts.map

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

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

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

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JAVA_PACK_SKILLS = void 0;
+/**
+ * Java / Spring Boot skill pack (@bk-java).
+ * Activated for projects with pom.xml or build.gradle.
+ */
+exports.JAVA_PACK_SKILLS = [
+    {
+        name: 'spring-layered-architecture',
+        version: '1.0.0',
+        description: 'Spring Boot layered architecture: Controller → Service → Repository',
+        scope: 'pack',
+        pack: '@bk-java',
+        language: ['java'],
+        triggers: [
+            'spring', 'springboot', 'spring boot', 'controller', 'service', 'repository',
+            'componente', 'component', 'bean', 'inyeccion', 'injection', 'autowired',
+            'rest api', 'endpoint', 'api rest',
+        ],
+        systemPromptAddition: `## Spring Boot Layered Architecture
+
+### Capas (dependencias fluyen hacia abajo)
+\`\`\`
+Controller (@RestController)  ←  HTTP, validación de request, mapeo DTO
+    ↓
+Service (@Service)            ←  lógica de negocio, transacciones
+    ↓
+Repository (@Repository)      ←  acceso a datos, JPA/JDBC
+    ↓
+Domain (entities, value objects) ← sin dependencias de Spring
+\`\`\`
+
+### Controller — solo HTTP
+\`\`\`java
+@RestController
+@RequestMapping("/api/users")
+@RequiredArgsConstructor
+public class UserController {
+    private final UserService userService;
+
+    @GetMapping("/{id}")
+    public ResponseEntity<UserResponse> findById(@PathVariable UUID id) {
+        return ResponseEntity.ok(userService.findById(id));
+    }
+
+    @PostMapping
+    @ResponseStatus(HttpStatus.CREATED)
+    public UserResponse create(@RequestBody @Valid CreateUserRequest request) {
+        return userService.create(request);
+    }
+}
+\`\`\`
+
+### Service — lógica de negocio
+\`\`\`java
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+public class UserService {
+    private final UserRepository userRepository;
+
+    public UserResponse findById(UUID id) {
+        return userRepository.findById(id)
+            .map(UserMapper::toResponse)
+            .orElseThrow(() -> new ResourceNotFoundException("User", id));
+    }
+
+    @Transactional
+    public UserResponse create(CreateUserRequest request) {
+        // validaciones de negocio aquí
+        User user = UserMapper.fromRequest(request);
+        return UserMapper.toResponse(userRepository.save(user));
+    }
+}
+\`\`\`
+
+### Reglas
+- Nunca expongas entidades JPA directamente — usa DTOs (record o class)
+- \`@Transactional(readOnly = true)\` a nivel de clase; \`@Transactional\` en métodos de escritura
+- Usa \`@RequiredArgsConstructor\` (Lombok) para inyección por constructor — nunca \`@Autowired\` en campo
+- Los controllers no llaman a repositories directamente`,
+    },
+    {
+        name: 'spring-exception-handling',
+        version: '1.0.0',
+        description: 'Global exception handling with @ControllerAdvice and ProblemDetail (RFC 7807)',
+        scope: 'pack',
+        pack: '@bk-java',
+        language: ['java'],
+        triggers: [
+            'exception', 'error handling', 'manejo de errores', 'controlleradvice',
+            'exceptionhandler', 'problem detail', 'errorresponse', '404', '400', '500',
+        ],
+        systemPromptAddition: `## Spring Exception Handling
+
+### Excepciones de dominio
+\`\`\`java
+public class ResourceNotFoundException extends RuntimeException {
+    public ResourceNotFoundException(String resource, Object id) {
+        super(resource + " not found: " + id);
+    }
+}
+
+public class BusinessRuleException extends RuntimeException {
+    public BusinessRuleException(String message) { super(message); }
+}
+\`\`\`
+
+### Handler global (Spring 6 / Boot 3 — ProblemDetail RFC 7807)
+\`\`\`java
+@RestControllerAdvice
+public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
+
+    @ExceptionHandler(ResourceNotFoundException.class)
+    ProblemDetail handleNotFound(ResourceNotFoundException ex) {
+        return ProblemDetail.forStatusAndDetail(HttpStatus.NOT_FOUND, ex.getMessage());
+    }
+
+    @ExceptionHandler(BusinessRuleException.class)
+    ProblemDetail handleBusiness(BusinessRuleException ex) {
+        return ProblemDetail.forStatusAndDetail(HttpStatus.UNPROCESSABLE_ENTITY, ex.getMessage());
+    }
+
+    @Override
+    protected ResponseEntity<Object> handleMethodArgumentNotValid(
+            MethodArgumentNotValidException ex, HttpHeaders headers,
+            HttpStatusCode status, WebRequest request) {
+        ProblemDetail pd = ProblemDetail.forStatus(HttpStatus.BAD_REQUEST);
+        pd.setProperty("errors", ex.getBindingResult().getFieldErrors().stream()
+            .map(e -> e.getField() + ": " + e.getDefaultMessage())
+            .toList());
+        return ResponseEntity.badRequest().body(pd);
+    }
+}
+\`\`\`
+
+### Reglas
+- Nunca devuelvas stack traces al cliente — loguéalos internamente
+- Usa \`ProblemDetail\` (Spring 6+) para respuestas de error estándar
+- Las excepciones de dominio son RuntimeException — no checked exceptions
+- Loguea con \`log.warn\` para 4xx y \`log.error\` para 5xx`,
+    },
+    {
+        name: 'spring-testing',
+        version: '1.0.0',
+        description: 'JUnit 5, Mockito, @WebMvcTest and @DataJpaTest slices',
+        scope: 'pack',
+        pack: '@bk-java',
+        language: ['java'],
+        triggers: [
+            'test', 'tests', 'testing', 'junit', 'mockito', 'mock', 'prueba',
+            'webmvctest', 'datajpatest', 'springboottest', 'coverage', 'cobertura',
+        ],
+        systemPromptAddition: `## Spring Testing
+
+### Test de servicio (puro, sin Spring)
+\`\`\`java
+@ExtendWith(MockitoExtension.class)
+class UserServiceTest {
+    @Mock UserRepository userRepository;
+    @InjectMocks UserService userService;
+
+    @Test
+    void findById_whenExists_returnsUser() {
+        var user = new User(UUID.randomUUID(), "ana@example.com");
+        when(userRepository.findById(user.getId())).thenReturn(Optional.of(user));
+
+        var result = userService.findById(user.getId());
+
+        assertThat(result.email()).isEqualTo("ana@example.com");
+        verify(userRepository).findById(user.getId());
+    }
+
+    @Test
+    void findById_whenMissing_throwsNotFound() {
+        var id = UUID.randomUUID();
+        when(userRepository.findById(id)).thenReturn(Optional.empty());
+
+        assertThatThrownBy(() -> userService.findById(id))
+            .isInstanceOf(ResourceNotFoundException.class);
+    }
+}
+\`\`\`
+
+### Test de controller (slice — solo capa HTTP)
+\`\`\`java
+@WebMvcTest(UserController.class)
+class UserControllerTest {
+    @Autowired MockMvc mockMvc;
+    @MockBean UserService userService;
+
+    @Test
+    void getById_returns200() throws Exception {
+        var response = new UserResponse(UUID.randomUUID(), "ana@example.com");
+        when(userService.findById(any())).thenReturn(response);
+
+        mockMvc.perform(get("/api/users/{id}", response.id()))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.email").value("ana@example.com"));
+    }
+}
+\`\`\`
+
+### Reglas
+- Prefiere unit tests de servicio (sin contexto Spring) para lógica de negocio
+- Usa \`@WebMvcTest\` para HTTP layer y \`@DataJpaTest\` para repositorios — no \`@SpringBootTest\` para todo
+- Usa AssertJ (\`assertThat\`) sobre JUnit assertions — más legible
+- Nombra los tests: \`{metodo}_{condicion}_{resultado}\``,
+    },
+    {
+        name: 'spring-jpa',
+        version: '1.0.0',
+        description: 'JPA entities, Spring Data repositories and transaction management',
+        scope: 'pack',
+        pack: '@bk-java',
+        language: ['java'],
+        triggers: [
+            'jpa', 'hibernate', 'entity', 'entidad', 'repository', 'repositorio',
+            'transaction', 'transaccion', 'query', 'jpql', 'migration', 'migracion',
+            'flyway', 'liquibase', 'database', 'base de datos',
+        ],
+        systemPromptAddition: `## Spring Data JPA
+
+### Entity
+\`\`\`java
+@Entity
+@Table(name = "users")
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED) // JPA requiere constructor sin args
+public class User {
+    @Id
+    @GeneratedValue(strategy = GenerationType.UUID)
+    private UUID id;
+
+    @Column(nullable = false, unique = true)
+    private String email;
+
+    @CreationTimestamp
+    private Instant createdAt;
+
+    public User(String email) { // constructor de dominio
+        this.email = email;
+    }
+}
+\`\`\`
+
+### Repository
+\`\`\`java
+public interface UserRepository extends JpaRepository<User, UUID> {
+    Optional<User> findByEmail(String email);
+
+    @Query("SELECT u FROM User u WHERE u.createdAt >= :since")
+    List<User> findRecentUsers(@Param("since") Instant since);
+
+    // Para updates masivos usa @Modifying + @Transactional
+    @Modifying
+    @Transactional
+    @Query("UPDATE User u SET u.email = :email WHERE u.id = :id")
+    int updateEmail(@Param("id") UUID id, @Param("email") String email);
+}
+\`\`\`
+
+### Reglas
+- Usa \`@NoArgsConstructor(access = PROTECTED)\` — JPA lo necesita pero no expongas el constructor vacío
+- No uses \`@Setter\` en entidades — modifica el estado con métodos de dominio
+- Nunca serialices entidades JPA a JSON directamente — usa DTOs (records)
+- Migraciones con Flyway o Liquibase — nunca \`spring.jpa.hibernate.ddl-auto=update\` en producción
+- Fetch LAZY por defecto para colecciones (\`@OneToMany\`)`,
+    },
+];
+//# sourceMappingURL=java-pack.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"java-pack.js","sourceRoot":"","sources":["../../../src/skills/builtins/java-pack.ts"],"names":[],"mappings":";;;AAEA;;;GAGG;AACU,QAAA,gBAAgB,GAAY;IACrC;QACI,IAAI,EAAE,6BAA6B;QACnC,OAAO,EAAE,OAAO;QAChB,WAAW,EAAE,yEAAyE;QACtF,KAAK,EAAE,MAAM;QACb,IAAI,EAAE,UAAU;QAChB,QAAQ,EAAE,CAAC,MAAM,CAAC;QAClB,QAAQ,EAAE;YACN,QAAQ,EAAE,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,SAAS,EAAE,YAAY;YAC5E,YAAY,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW;YACxE,UAAU,EAAE,UAAU,EAAE,UAAU;SACrC;QACD,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wDA6D0B;KACnD;IACD;QACI,IAAI,EAAE,2BAA2B;QACjC,OAAO,EAAE,OAAO;QAChB,WAAW,EAAE,+EAA+E;QAC5F,KAAK,EAAE,MAAM;QACb,IAAI,EAAE,UAAU;QAChB,QAAQ,EAAE,CAAC,MAAM,CAAC;QAClB,QAAQ,EAAE;YACN,WAAW,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,kBAAkB;YACtE,kBAAkB,EAAE,gBAAgB,EAAE,eAAe,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK;SAC7E;QACD,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4DA+C8B;KACvD;IACD;QACI,IAAI,EAAE,gBAAgB;QACtB,OAAO,EAAE,OAAO;QAChB,WAAW,EAAE,uDAAuD;QACpE,KAAK,EAAE,MAAM;QACb,IAAI,EAAE,UAAU;QAChB,QAAQ,EAAE,CAAC,MAAM,CAAC;QAClB,QAAQ,EAAE;YACN,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ;YAChE,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,UAAU,EAAE,WAAW;SACzE;QACD,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yDAsD2B;KACpD;IACD;QACI,IAAI,EAAE,YAAY;QAClB,OAAO,EAAE,OAAO;QAChB,WAAW,EAAE,mEAAmE;QAChF,KAAK,EAAE,MAAM;QACb,IAAI,EAAE,UAAU;QAChB,QAAQ,EAAE,CAAC,MAAM,CAAC;QAClB,QAAQ,EAAE;YACN,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,YAAY,EAAE,aAAa;YACpE,aAAa,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW;YACvE,QAAQ,EAAE,WAAW,EAAE,UAAU,EAAE,eAAe;SACrD;QACD,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2DA8C6B;KACtD;CACJ,CAAC"}

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

@@ -0,0 +1,9 @@
+import type { Skill } from '@backendkit-labs/agent-core';
+/**
+ * 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).
+ */
+export declare const KOTLIN_PACK_SKILLS: Skill[];
+//# sourceMappingURL=kotlin-pack.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kotlin-pack.d.ts","sourceRoot":"","sources":["../../../src/skills/builtins/kotlin-pack.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAEzD;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,KAAK,EAyRrC,CAAC"}