@rubix0270/arboris 1.0.2 → 1.0.4

package/prisma/skills/android-clean-architecture/SKILL.md

@@ -1,340 +0,0 @@
----
-name: android-clean-architecture
-description: Clean Architecture patterns for Android and Kotlin Multiplatform projects — module structure, dependency rules, UseCases, Repositories, and data layer patterns.
-metadata:
-  origin: ECC
----
-
-# Android Clean Architecture
-
-Clean Architecture patterns for Android and KMP projects. Covers module boundaries, dependency inversion, UseCase/Repository patterns, and data layer design with Room, SQLDelight, and Ktor.
-
-## When to Activate
-
-- Structuring Android or KMP project modules
-- Implementing UseCases, Repositories, or DataSources
-- Designing data flow between layers (domain, data, presentation)
-- Setting up dependency injection with Koin or Hilt
-- Working with Room, SQLDelight, or Ktor in a layered architecture
-
-## Module Structure
-
-### Recommended Layout
-
-```
-project/
-├── app/                  # Android entry point, DI wiring, Application class
-├── core/                 # Shared utilities, base classes, error types
-├── domain/               # UseCases, domain models, repository interfaces (pure Kotlin)
-├── data/                 # Repository implementations, DataSources, DB, network
-├── presentation/         # Screens, ViewModels, UI models, navigation
-├── design-system/        # Reusable Compose components, theme, typography
-└── feature/              # Feature modules (optional, for larger projects)
-    ├── auth/
-    ├── settings/
-    └── profile/
-```
-
-### Dependency Rules
-
-```
-app → presentation, domain, data, core
-presentation → domain, design-system, core
-data → domain, core
-domain → core (or no dependencies)
-core → (nothing)
-```
-
-**Critical**: `domain` must NEVER depend on `data`, `presentation`, or any framework. It contains pure Kotlin only.
-
-## Domain Layer
-
-### UseCase Pattern
-
-Each UseCase represents one business operation. Use `operator fun invoke` for clean call sites:
-
-```kotlin
-class GetItemsByCategoryUseCase(
-    private val repository: ItemRepository
-) {
-    suspend operator fun invoke(category: String): Result<List<Item>> {
-        return repository.getItemsByCategory(category)
-    }
-}
-
-// Flow-based UseCase for reactive streams
-class ObserveUserProgressUseCase(
-    private val repository: UserRepository
-) {
-    operator fun invoke(userId: String): Flow<UserProgress> {
-        return repository.observeProgress(userId)
-    }
-}
-```
-
-### Domain Models
-
-Domain models are plain Kotlin data classes — no framework annotations:
-
-```kotlin
-data class Item(
-    val id: String,
-    val title: String,
-    val description: String,
-    val tags: List<String>,
-    val status: Status,
-    val category: String
-)
-
-enum class Status { DRAFT, ACTIVE, ARCHIVED }
-```
-
-### Repository Interfaces
-
-Defined in domain, implemented in data:
-
-```kotlin
-interface ItemRepository {
-    suspend fun getItemsByCategory(category: String): Result<List<Item>>
-    suspend fun saveItem(item: Item): Result<Unit>
-    fun observeItems(): Flow<List<Item>>
-}
-```
-
-## Data Layer
-
-### Repository Implementation
-
-Coordinates between local and remote data sources:
-
-```kotlin
-class ItemRepositoryImpl(
-    private val localDataSource: ItemLocalDataSource,
-    private val remoteDataSource: ItemRemoteDataSource
-) : ItemRepository {
-
-    override suspend fun getItemsByCategory(category: String): Result<List<Item>> {
-        return runCatching {
-            val remote = remoteDataSource.fetchItems(category)
-            localDataSource.insertItems(remote.map { it.toEntity() })
-            localDataSource.getItemsByCategory(category).map { it.toDomain() }
-        }
-    }
-
-    override suspend fun saveItem(item: Item): Result<Unit> {
-        return runCatching {
-            localDataSource.insertItems(listOf(item.toEntity()))
-        }
-    }
-
-    override fun observeItems(): Flow<List<Item>> {
-        return localDataSource.observeAll().map { entities ->
-            entities.map { it.toDomain() }
-        }
-    }
-}
-```
-
-### Mapper Pattern
-
-Keep mappers as extension functions near the data models:
-
-```kotlin
-// In data layer
-fun ItemEntity.toDomain() = Item(
-    id = id,
-    title = title,
-    description = description,
-    tags = tags.split("|"),
-    status = Status.valueOf(status),
-    category = category
-)
-
-fun ItemDto.toEntity() = ItemEntity(
-    id = id,
-    title = title,
-    description = description,
-    tags = tags.joinToString("|"),
-    status = status,
-    category = category
-)
-```
-
-### Room Database (Android)
-
-```kotlin
-@Entity(tableName = "items")
-data class ItemEntity(
-    @PrimaryKey val id: String,
-    val title: String,
-    val description: String,
-    val tags: String,
-    val status: String,
-    val category: String
-)
-
-@Dao
-interface ItemDao {
-    @Query("SELECT * FROM items WHERE category = :category")
-    suspend fun getByCategory(category: String): List<ItemEntity>
-
-    @Upsert
-    suspend fun upsert(items: List<ItemEntity>)
-
-    @Query("SELECT * FROM items")
-    fun observeAll(): Flow<List<ItemEntity>>
-}
-```
-
-### SQLDelight (KMP)
-
-```sql
--- Item.sq
-CREATE TABLE ItemEntity (
-    id TEXT NOT NULL PRIMARY KEY,
-    title TEXT NOT NULL,
-    description TEXT NOT NULL,
-    tags TEXT NOT NULL,
-    status TEXT NOT NULL,
-    category TEXT NOT NULL
-);
-
-getByCategory:
-SELECT * FROM ItemEntity WHERE category = ?;
-
-upsert:
-INSERT OR REPLACE INTO ItemEntity (id, title, description, tags, status, category)
-VALUES (?, ?, ?, ?, ?, ?);
-
-observeAll:
-SELECT * FROM ItemEntity;
-```
-
-### Ktor Network Client (KMP)
-
-```kotlin
-class ItemRemoteDataSource(private val client: HttpClient) {
-
-    suspend fun fetchItems(category: String): List<ItemDto> {
-        return client.get("api/items") {
-            parameter("category", category)
-        }.body()
-    }
-}
-
-// HttpClient setup with content negotiation
-val httpClient = HttpClient {
-    install(ContentNegotiation) { json(Json { ignoreUnknownKeys = true }) }
-    install(Logging) { level = LogLevel.HEADERS }
-    defaultRequest { url("https://api.example.com/") }
-}
-```
-
-## Dependency Injection
-
-### Koin (KMP-friendly)
-
-```kotlin
-// Domain module
-val domainModule = module {
-    factory { GetItemsByCategoryUseCase(get()) }
-    factory { ObserveUserProgressUseCase(get()) }
-}
-
-// Data module
-val dataModule = module {
-    single<ItemRepository> { ItemRepositoryImpl(get(), get()) }
-    single { ItemLocalDataSource(get()) }
-    single { ItemRemoteDataSource(get()) }
-}
-
-// Presentation module
-val presentationModule = module {
-    viewModelOf(::ItemListViewModel)
-    viewModelOf(::DashboardViewModel)
-}
-```
-
-### Hilt (Android-only)
-
-```kotlin
-@Module
-@InstallIn(SingletonComponent::class)
-abstract class RepositoryModule {
-    @Binds
-    abstract fun bindItemRepository(impl: ItemRepositoryImpl): ItemRepository
-}
-
-@HiltViewModel
-class ItemListViewModel @Inject constructor(
-    private val getItems: GetItemsByCategoryUseCase
-) : ViewModel()
-```
-
-## Error Handling
-
-### Result/Try Pattern
-
-Use `Result<T>` or a custom sealed type for error propagation:
-
-```kotlin
-sealed interface Try<out T> {
-    data class Success<T>(val value: T) : Try<T>
-    data class Failure(val error: AppError) : Try<Nothing>
-}
-
-sealed interface AppError {
-    data class Network(val message: String) : AppError
-    data class Database(val message: String) : AppError
-    data object Unauthorized : AppError
-}
-
-// In ViewModel — map to UI state
-viewModelScope.launch {
-    when (val result = getItems(category)) {
-        is Try.Success -> _state.update { it.copy(items = result.value, isLoading = false) }
-        is Try.Failure -> _state.update { it.copy(error = result.error.toMessage(), isLoading = false) }
-    }
-}
-```
-
-## Convention Plugins (Gradle)
-
-For KMP projects, use convention plugins to reduce build file duplication:
-
-```kotlin
-// build-logic/src/main/kotlin/kmp-library.gradle.kts
-plugins {
-    id("org.jetbrains.kotlin.multiplatform")
-}
-
-kotlin {
-    androidTarget()
-    iosX64(); iosArm64(); iosSimulatorArm64()
-    sourceSets {
-        commonMain.dependencies { /* shared deps */ }
-        commonTest.dependencies { implementation(kotlin("test")) }
-    }
-}
-```
-
-Apply in modules:
-
-```kotlin
-// domain/build.gradle.kts
-plugins { id("kmp-library") }
-```
-
-## Anti-Patterns to Avoid
-
-- Importing Android framework classes in `domain` — keep it pure Kotlin
-- Exposing database entities or DTOs to the UI layer — always map to domain models
-- Putting business logic in ViewModels — extract to UseCases
-- Using `GlobalScope` or unstructured coroutines — use `viewModelScope` or structured concurrency
-- Fat repository implementations — split into focused DataSources
-- Circular module dependencies — if A depends on B, B must not depend on A
-
-## References
-
-See skill: `compose-multiplatform-patterns` for UI patterns.
-See skill: `kotlin-coroutines-flows` for async patterns.

package/prisma/skills/angular-developer/SKILL.md

@@ -1,155 +0,0 @@
----
-name: angular-developer
-description: Generates Angular code and provides architectural guidance. Trigger when creating projects, components, or services, or for best practices on reactivity (signals, linkedSignal, resource), forms, dependency injection, routing, SSR, accessibility (ARIA), animations, styling (component styles, Tailwind CSS), testing, or CLI tooling.
-metadata:
-  origin: ECC
----
-
-# Angular Developer Guidelines
-
-## When to Activate
-
-- Working in any Angular project or codebase
-- Creating or scaffolding a new Angular project, application, or library
-- Generating components, services, directives, pipes, guards, or resolvers
-- Implementing reactivity with Angular Signals, `linkedSignal`, or `resource`
-- Working with Angular forms (signal forms, reactive forms, or template-driven)
-- Setting up dependency injection, routing, lazy loading, or route guards
-- Adding accessibility (ARIA), animations, or component styling
-- Writing or debugging Angular-specific tests (unit, component harness, E2E)
-- Configuring Angular CLI tooling or the Angular MCP server
-
-1. Always analyze the project's Angular version before providing guidance, as best practices and available features can vary significantly between versions. If creating a new project with Angular CLI, do not specify a version unless prompted by the user.
-
-2. When generating code, follow Angular's style guide and best practices for maintainability and performance. Use the Angular CLI for scaffolding components, services, directives, pipes, and routes to ensure consistency.
-
-3. Once you finish generating code, run `ng build` to ensure there are no build errors. If there are errors, analyze the error messages and fix them before proceeding. Do not skip this step, as it is critical for ensuring the generated code is correct and functional.
-
-## Creating New Projects
-
-If no guidelines are provided by the user, use these defaults when creating a new Angular project:
-
-1. Use the latest stable version of Angular unless the user specifies otherwise.
-2. Prefer Signal Forms for new projects only when the target Angular version supports them. [Find out more](references/signal-forms.md).
-
-**Execution Rules for `ng new`:**
-When asked to create a new Angular project, you must determine the correct execution command by following these strict steps:
-
-**Step 1: Check for an explicit user version.**
-
-- **IF** the user requests a specific version (e.g., Angular 15), bypass local installations and strictly use `npx`.
-- **Command:** `npx @angular/cli@<requested_version> new <project-name>`
-
-**Step 2: Check for an existing Angular installation.**
-
-- **IF** no specific version is requested, run `ng version` in the terminal to check if the Angular CLI is already installed on the system.
-- **IF** the command succeeds and returns an installed version, use the local/global installation directly.
-- **Command:** `ng new <project-name>`
-
-**Step 3: Fallback to Latest.**
-
-- **IF** no specific version is requested AND the `ng version` command fails (indicating no Angular installation exists), you must use `npx` to fetch the latest version.
-- **Command:** `npx @angular/cli@latest new <project-name>`
-
-## Components
-
-When working with Angular components, consult the following references based on the task:
-
-- **Fundamentals**: Anatomy, metadata, core concepts, and template control flow (@if, @for, @switch). Read [components.md](references/components.md)
-- **Inputs**: Signal-based inputs, transforms, and model inputs. Read [inputs.md](references/inputs.md)
-- **Outputs**: Signal-based outputs and custom event best practices. Read [outputs.md](references/outputs.md)
-- **Host Elements**: Host bindings and attribute injection. Read [host-elements.md](references/host-elements.md)
-
-If you require deeper documentation not found in the references above, read the documentation at `https://angular.dev/guide/components`.
-
-## Reactivity and Data Management
-
-When managing state and data reactivity, use Angular Signals and consult the following references:
-
-- **Signals Overview**: Core signal concepts (`signal`, `computed`), reactive contexts, and `untracked`. Read [signals-overview.md](references/signals-overview.md)
-- **Dependent State (`linkedSignal`)**: Creating writable state linked to source signals. Read [linked-signal.md](references/linked-signal.md)
-- **Async Reactivity (`resource`)**: Fetching asynchronous data directly into signal state. Read [resource.md](references/resource.md)
-- **Side Effects (`effect`)**: Logging, third-party DOM manipulation (`afterRenderEffect`), and when NOT to use effects. Read [effects.md](references/effects.md)
-
-## Forms
-
-In most cases for new apps, **prefer signal forms**. When making a forms decision, analyze the project and consider the following guidelines:
-
-- If the application version supports Signal Forms and this is a new form, **prefer signal forms**.
-- For older applications or existing forms, match the application's current form strategy.
-
-- **Signal Forms**: Use signals for form state management. Read [signal-forms.md](references/signal-forms.md)
-- **Template-driven forms**: Use for simple forms. Read [template-driven-forms.md](references/template-driven-forms.md)
-- **Reactive forms**: Use for complex forms. Read [reactive-forms.md](references/reactive-forms.md)
-
-## Dependency Injection
-
-When implementing dependency injection in Angular, follow these guidelines:
-
-- **Fundamentals**: Overview of Dependency Injection, services, and the `inject()` function. Read [di-fundamentals.md](references/di-fundamentals.md)
-- **Creating and Using Services**: Creating services, the `providedIn: 'root'` option, and injecting into components or other services. Read [creating-services.md](references/creating-services.md)
-- **Defining Dependency Providers**: Automatic vs manual provision, `InjectionToken`, `useClass`, `useValue`, `useFactory`, and scopes. Read [defining-providers.md](references/defining-providers.md)
-- **Injection Context**: Where `inject()` is allowed, `runInInjectionContext`, and `assertInInjectionContext`. Read [injection-context.md](references/injection-context.md)
-- **Hierarchical Injectors**: The `EnvironmentInjector` vs `ElementInjector`, resolution rules, modifiers (`optional`, `skipSelf`), and `providers` vs `viewProviders`. Read [hierarchical-injectors.md](references/hierarchical-injectors.md)
-
-## Angular Aria
-
-When building accessible custom components for any of the following patterns: Accordion, Listbox, Combobox, Menu, Tabs, Toolbar, Tree, Grid, consult the following reference:
-
-- **Angular Aria Components**: Building headless, accessible components (Accordion, Listbox, Combobox, Menu, Tabs, Toolbar, Tree, Grid) and styling ARIA attributes. Read [angular-aria.md](references/angular-aria.md)
-
-## Routing
-
-When implementing navigation in Angular, consult the following references:
-
-- **Define Routes**: URL paths, static vs dynamic segments, wildcards, and redirects. Read [define-routes.md](references/define-routes.md)
-- **Route Loading Strategies**: Eager vs lazy loading, and context-aware loading. Read [loading-strategies.md](references/loading-strategies.md)
-- **Show Routes with Outlets**: Using `<router-outlet>`, nested outlets, and named outlets. Read [show-routes-with-outlets.md](references/show-routes-with-outlets.md)
-- **Navigate to Routes**: Declarative navigation with `RouterLink` and programmatic navigation with `Router`. Read [navigate-to-routes.md](references/navigate-to-routes.md)
-- **Control Route Access with Guards**: Implementing `CanActivate`, `CanMatch`, and other guards for security. Read [route-guards.md](references/route-guards.md)
-- **Data Resolvers**: Pre-fetching data before route activation with `ResolveFn`. Read [data-resolvers.md](references/data-resolvers.md)
-- **Router Lifecycle and Events**: Chronological order of navigation events and debugging. Read [router-lifecycle.md](references/router-lifecycle.md)
-- **Rendering Strategies**: CSR, SSG (Prerendering), and SSR with hydration. Read [rendering-strategies.md](references/rendering-strategies.md)
-- **Route Transition Animations**: Enabling and customizing the View Transitions API. Read [route-animations.md](references/route-animations.md)
-
-If you require deeper documentation or more context, visit the [official Angular Routing guide](https://angular.dev/guide/routing).
-
-## Styling and Animations
-
-When implementing styling and animations in Angular, consult the following references:
-
-- **Using Tailwind CSS with Angular**: Integrating Tailwind CSS into Angular projects. Read [tailwind-css.md](references/tailwind-css.md)
-- **Angular Animations**: Using native CSS (recommended) or the legacy DSL for dynamic effects. Read [angular-animations.md](references/angular-animations.md)
-- **Styling components**: Best practices for component styles and encapsulation. Read [component-styling.md](references/component-styling.md)
-
-## Testing
-
-When writing or updating tests, consult the following references based on the task:
-
-- **Fundamentals**: Best practices for unit testing, async patterns, and `TestBed`. Read [testing-fundamentals.md](references/testing-fundamentals.md)
-- **Component Harnesses**: Standard patterns for robust component interaction. Read [component-harnesses.md](references/component-harnesses.md)
-- **Router Testing**: Using `RouterTestingHarness` for reliable navigation tests. Read [router-testing.md](references/router-testing.md)
-- **End-to-End (E2E) Testing**: Best practices for E2E tests with Cypress or Playwright. Read [e2e-testing.md](references/e2e-testing.md)
-
-## Tooling
-
-When working with Angular tooling, consult the following references:
-
-- **Angular CLI**: Creating applications, generating code (components, routes, services), serving, and building. Read [cli.md](references/cli.md)
-- **Angular MCP Server**: Available tools, configuration, and experimental features. Read [mcp.md](references/mcp.md)
-
-## Anti-Patterns
-
-- Using `null` or `undefined` as initial signal form field values — use `''`, `0`, or `[]` instead
-- Accessing form field state flags without calling the field first: `form.field.valid()` — use `form.field().valid()`
-- Starting new forms with older form APIs when the target Angular version supports Signal Forms
-- Setting `min`, `max`, `value`, `disabled`, or `readonly` HTML attributes on `[formField]` inputs — define these as schema rules instead
-- Calling `inject()` outside an injection context — use `runInInjectionContext` when needed
-- Using `effect()` for derived state that should use `computed()`
-- Referencing `$parent.$index` in nested `@for` loops — Angular does not support `$parent`; use `let outerIdx = $index` instead
-
-## Related Skills
-
-- `tdd-workflow` — test-driven development workflow applicable to Angular components and services
-- `security-review` — security checklist for web applications including Angular-specific concerns
-- `frontend-patterns` — general frontend patterns for context on React/Next.js approaches

package/prisma/skills/angular-developer/references/angular-animations.md

@@ -1,160 +0,0 @@
-# Angular Animations
-
-When animating elements in Angular, **first analyze the project's Angular version** in `package.json`.
-For modern applications (**Angular v20.2 and above**), prefer using native CSS with `animate.enter` and `animate.leave`. For older applications, you may need to use the deprecated `@angular/animations` package.
-
-## 1. Native CSS Animations (v20.2+ Recommended)
-
-Modern Angular provides `animate.enter` and `animate.leave` to animate elements as they enter or leave the DOM. They apply CSS classes at the appropriate times.
-
-### `animate.enter` and `animate.leave`
-
-Use these directly on elements to apply CSS classes during the enter or leave phase. Angular automatically removes the enter classes when the animation completes. For `animate.leave`, Angular waits for the animation to finish before removing the element from the DOM.
-
-`animate.enter` example:
-
-```html
-@if (isShown()) {
-<div class="enter-container" animate.enter="enter-animation">
-  <p>The box is entering.</p>
-</div>
-}
-```
-
-```css
-/* Ensure you have a starting style if using transitions instead of keyframes */
-.enter-container {
-  border: 1px solid #dddddd;
-  margin-top: 1em;
-  padding: 20px;
-  font-weight: bold;
-  font-size: 20px;
-}
-.enter-container p {
-  margin: 0;
-}
-.enter-animation {
-  animation: slide-fade 1s;
-}
-@keyframes slide-fade {
-  from {
-    opacity: 0;
-    transform: translateY(20px);
-  }
-  to {
-    opacity: 1;
-    transform: translateY(0);
-  }
-}
-```
-
-_Note: `animate.leave` may be added to child elements being removed._
-
-### Event Bindings and Third-party Libraries
-
-You can bind to `(animate.enter)` and `(animate.leave)` to call functions or use JS libraries like GSAP.
-
-```html
-@if(show()) {
-<div (animate.leave)="onLeave($event)">...</div>
-}
-```
-
-```ts
-import { AnimationCallbackEvent } from '@angular/core';
-
-onLeave(event: AnimationCallbackEvent) {
-  // Custom animation logic here
-  // CRITICAL: You MUST call animationComplete() when done so Angular removes the element!
-  event.animationComplete();
-}
-```
-
-## 2. Advanced CSS Animations
-
-CSS offers robust tools for advanced animation sequences.
-
-### Animating State and Styles
-
-Toggle CSS classes on elements using property binding to trigger transitions.
-
-```html
-<div [class.open]="isOpen">...</div>
-```
-
-```css
-div {
-  transition: height 0.3s ease-out;
-  height: 100px;
-}
-div.open {
-  height: 200px;
-}
-```
-
-### Animating Auto Height
-
-You can use `css-grid` to animate to auto height.
-
-```css
-.container {
-  display: grid;
-  grid-template-rows: 0fr;
-  transition: grid-template-rows 0.3s;
-}
-.container.open {
-  grid-template-rows: 1fr;
-}
-.container > div {
-  overflow: hidden;
-}
-```
-
-### Staggering and Parallel Animations
-
-- **Staggering**: Use `animation-delay` or `transition-delay` with different values for items in a list.
-- **Parallel**: Apply multiple animations in the `animation` shorthand (e.g., `animation: rotate 3s, fade-in 2s;`).
-
-### Programmatic Control
-
-Retrieve animations directly using standard Web APIs:
-
-```ts
-const animations = element.getAnimations();
-animations.forEach((anim) => anim.pause());
-```
-
-## 3. Legacy Animations DSL (Deprecated)
-
-For older projects (pre v20.2 or where `@angular/animations` is already heavily used), you use the component metadata DSL.
-
-**Important:** Do not mix legacy animations and `animate.enter`/`leave` in the same component.
-
-### Setup
-
-```ts
-bootstrapApplication(App, {
-  providers: [provideAnimationsAsync()],
-});
-```
-
-### Defining Transitions
-
-```ts
-import {signal} from '@angular/core';
-import {trigger, state, style, animate, transition} from '@angular/animations';
-
-@Component({
-  animations: [
-    trigger('openClose', [
-      state('open', style({opacity: 1})),
-      state('closed', style({opacity: 0})),
-      transition('open <=> closed', [animate('0.5s')]),
-    ]),
-  ],
-  template: `<div [@openClose]="isOpen() ? 'open' : 'closed'">...</div>`,
-})
-export class OpenClose {
-  isOpen = signal(true);
-}
-```