mad-pro-cli 1.0.0

package/index.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import initCommand from './lib/commands/init.js';
+
+program
+  .name('mad-pro')
+  .description('MAD Pro CLI - Boost your project with AI Expert Skills')
+  .version('1.0.0');
+
+program
+  .command('init')
+  .description('Initialize AI skills for your project')
+  .option('--ai <name>', 'Specify the AI bridge to use (e.g., antigravity)')
+  .action(initCommand);
+
+program.parse();

package/lib/commands/init.js

@@ -0,0 +1,42 @@
+import path from 'path';
+import fs from 'fs-extra';
+import chalk from 'chalk';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export default async function initCommand(options) {
+  const targetDir = process.cwd();
+  const aiName = options.ai || 'antigravity';
+
+  console.log(chalk.blue(`Initializing project with ${aiName} skills...`));
+
+  if (aiName === 'antigravity') {
+    try {
+      // In a published package, templates are bundled inside the package folder
+      const sourceSkillsPath = path.resolve(__dirname, '../../templates/mad-skills');
+      const destinationPath = path.join(targetDir, '.agent', 'skills', 'mad-skills');
+
+      console.log(chalk.yellow(`Installing skills to ${destinationPath}...`));
+
+      await fs.ensureDir(destinationPath);
+      
+      // Copy SKILL.md
+      await fs.copy(path.join(sourceSkillsPath, 'SKILL.md'), path.join(destinationPath, 'SKILL.md'));
+      
+      // Copy references directory
+      await fs.copy(path.join(sourceSkillsPath, 'references'), path.join(destinationPath, 'references'));
+
+      console.log(chalk.green('\n✅ Success! MAD Skills (Antigravity Bridge) installed.'));
+      console.log(chalk.cyan(`\nYour AI agent (Antigravity) can now find these skills at: ${destinationPath}`));
+      console.log(chalk.gray('\nTo use these skills, make sure your agent is instructed to read the .agent/skills directory.'));
+
+    } catch (error) {
+      console.error(chalk.red('\n❌ Error installing skills:'), error.message);
+    }
+  } else {
+    console.log(chalk.red(`\n❌ Unknown AI bridge: ${aiName}`));
+    console.log(chalk.gray('Available bridges: antigravity'));
+  }
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "mad-pro-cli",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "mad-pro": "./index.js"
+  },
+  "files": [
+    "index.js",
+    "lib",
+    "templates"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "fs-extra": "^11.3.4"
+  }
+}

package/templates/mad-skills/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: Modern Android Development (MAD) Skills
+description: Expert guidance for building robust, scalable, and maintainable Android applications using Modern Android Development (MAD) principles.
+---
+
+# Modern Android Development (MAD) Skills
+
+You are an expert Android developer specializing in Modern Android Development (MAD). Your goal is to help the user build high-quality, maintainable, and idiomatic Android applications following the official Google recommendations.
+
+Follow these core principles:
+
+1. **Multi-layered Architecture**: Separate code into UI, Domain, and Data layers.
+2. **Unidirectional Data Flow (UDF)**: Ensure a clear separation of state (flowing down) and events (flowing up).
+3. **Reactive Programming**: Use `Flow` and `StateFlow` to handle data streams across all layers.
+4. **Dependency Injection**: Use Hilt (recommended) or Koin to manage component dependencies.
+5. **Modern UI**: Use Jetpack Compose and Material 3 for all new features.
+
+## Architecture Layers
+
+### 1. UI Layer
+
+- **[State Management](references/state_management.md)**: `UiState` patterns, ViewModels, and `collectAsStateWithLifecycle`.
+- **[UI Patterns](references/ui_patterns.md)**: Slot APIs and reusable components.
+- **[Layouts & Structure](references/layouts.md)**: Building responsive UI with `Scaffold` and Material 3.
+- **[Modifiers](references/modifiers.md)**: Chaining, ordering, and best practices.
+- **[Theming](references/theming.md)**: Material 3, typography, and Dynamic Color.
+- **[Navigation](references/navigation.md)**: Type-safe navigation.
+
+### 2. Domain Layer
+
+- **[Domain Layer](references/domain_layer.md)**: Use Cases and business logic isolation.
+
+### 3. Data Layer
+
+- **[Data Layer & Room](references/local_data.md)**: Offline-first with Room and DataStore.
+- **[Networking](references/network_data.md)**: Retrofit/Ktor, JSON serialization, and error handling.
+
+## Utilities & Specialized Skills
+
+- **[Architecture & DI](references/architecture_di.md)**: Orchestrating layers with Hilt and Koin.
+- **[Concurrency & Flow](references/concurrency.md)**: Coroutines and Flows across the stack.
+- **[Performance](references/performance.md)**: Stability and recomposition optimization.
+- **[Testing](references/testing.md)**: Semantic UI tests and Unit testing.
+- **[Security](references/security.md)**: Secure storage, biometrics, and permissions.
+- **[Advanced UI (Pro)](references/advanced_ui.md)**: Animations, Canvas, and custom layouts.
+- **[accessibility](references/accessibility.md)**: Inclusivity and Semantics.
+- **[Google Play Skills](references/google_play_skills.md)**: Compliance and release management.
+- **[WorkManager](references/workmanager.md)**: Persistent and reliable background tasks.
+
+### 4. Advanced & Ecosystem Skills
+
+- **[Modularization](references/modularization.md)**: Multi-module architecture and Version Catalogs.
+- **[KMP & Multiplatform](references/multiplatform.md)**: Logic sharing and Compose Multiplatform.
+- **[Adaptive UI](references/adaptive_layouts.md)**: Large screens, foldables, and Window Size Classes.
+- **[Observability & Health](references/observability.md)**: Crashlytics, Remote Config, and Monitoring.
+- **[Advanced Performance](references/advanced_performance.md)**: Baseline Profiles and Macrobenchmarking.
+- **[Deep Links](references/deeplinks.md)**: App Links and verified navigation.
+- **[On-Device AI](references/ai_ml.md)**: Gemini Nano and ML Kit integration.
+
+### 5. Engineering Excellence
+
+- **[Clean Architecture](references/clean_architecture.md)**: Layers, dependency rule, and MAD mapping.
+- **[SOLID Principles](references/solid_principles.md)**: Sustainable software design with Android examples.
+- **[Design Systems](references/design_systems.md)**: Professional tokens and shared components at scale.
+
+### 6. Platform Evolution & Migration
+
+- **[XML to Compose](references/migration_xml_to_compose.md)**: Gradual UI modernization.
+- **[Android to KMP](references/kmp_migration.md)**: Sharing logic across platforms.
+- **[Compose to CMP](references/cmp_migration.md)**: Sharing UI across platforms.
+- **[Automation & CI/CD](references/automation_cicd.md)**: GitHub Actions and Fastlane pipelines.
+
+## Code Style
+
+- Use trailing commas for all composable parameters.
+- Order parameters: `Modifier` first (if not required), then functional parameters last.
+- Naming: UI state classes should end in `UiState`. Events should end in `UiEvent`.

package/templates/mad-skills/references/accessibility.md

@@ -0,0 +1,63 @@
+# Accessibility in Jetpack Compose
+
+Creating inclusive apps is a core responsibility. Compose provides a powerful "Semantics" system to make your UI accessible to everyone.
+
+## 1. Content Descriptions
+
+The most basic step. Always provide a `contentDescription` for purely visual elements like `Icon` or `Image` unless they are decorative.
+
+```kotlin
+Icon(
+    imageVector = Icons.Default.Add,
+    contentDescription = "Add new contact" // Specific action
+)
+```
+
+## 2. Using Semantics
+
+Use the `Modifier.semantics` for complex components where the default behavior isn't enough.
+
+- **`mergeDescendants = true`**: Groups smaller elements into a single focusable entity for screen readers.
+- **`heading()`**: Marks a component as a header to help users navigate.
+- **`stateDescription`**: Provides a custom description for a state (e.g., "Active" instead of just "Checked").
+
+```kotlin
+Column(
+    modifier = Modifier
+        .semantics(mergeDescendants = true) {
+            heading()
+        }
+) {
+    Text("User Profile")
+    Text("John Doe")
+}
+```
+
+## 3. Custom Actions
+
+Use `onClickLabel` to specify what happens when an item is clicked, which is read by TalkBack.
+
+```kotlin
+Modifier.clickable(
+    onClickLabel = "Open detailed profile",
+    onClick = { ... }
+)
+```
+
+## 4. Visual Accessibility
+
+- **Touch Targets**: Ensure all interactive elements are at least **48x48dp**.
+- **Dynamic Type**: Use `sp` for text sizes to ensure they scale with the user's system font settings.
+- **Contrast**: Use Material 3 theme colors to ensure proper contrast ratios.
+
+- **TalkBack**: Test your app manually with TalkBack enabled.
+- **Accessibility Scanner**: Use the Google Accessibility Scanner app to identify common issues.
+- **Semantic Assertions in Tests**:
+
+## 5. Testing Accessibility
+
+```kotlin
+composeTestRule
+    .onNode(hasContentDescription("Add"))
+    .assertExists()
+```

package/templates/mad-skills/references/adaptive_layouts.md

@@ -0,0 +1,51 @@
+# Adaptive Layouts and Large Screens
+
+Modern Android apps must provide a great experience across all form factors: phones, foldables, tablets, and desktop.
+
+## 1. Window Size Classes
+
+Instead of targeting specific pixel widths, use Window Size Classes to categorize screen sizes:
+
+- **Compact**: Typical phone in portrait.
+- **Medium**: Small tablets, large foldables, or landscape phones.
+- **Expanded**: Large tablets and desktop.
+
+```kotlin
+@Composable
+fun MyApp(windowSize: WindowSizeClass) {
+    when (windowSize.widthSizeClass) {
+        WindowWidthSizeClass.Compact -> MyCompactUI()
+        WindowWidthSizeClass.Medium -> MyMediumUI()
+        WindowWidthSizeClass.Expanded -> MyExpandedUI()
+    }
+}
+```
+
+## 2. Canonical Layout Patterns
+
+Google recommends three standard patterns for large screens:
+
+- **List-Detail**: Best for browsing content while keeping context (e.g., Email, Messaging).
+- **Supporting Pane**: Main content with a side pane for secondary info (e.g., Documents with comments).
+- **Feed**: Grids that expand or stack based on width (e.g., Social Media, Photo Gallery).
+
+## 3. Navigation Components for Adaptive UI
+
+- **Bottom Navigation**: Use for Compact (phone) screens.
+- **Navigation Rail**: Use for Medium (tablet) screens.
+- **Navigation Drawer**: Use for Expanded (large tablet/desktop) screens.
+
+## 4. Handling Foldables
+
+Use the **Jetpack WindowManager** library to detect folding states:
+
+- **Tabletop Mode**: Half of the screen on a flat surface.
+- **Book Mode**: Half-folded vertically.
+
+Ensure content avoids the "hinge" area when the device is not flat.
+
+## 5. Testing Adaptive UI
+
+- Use **Resizing Emulators** in Android Studio.
+- Run UI tests with different configuration overrides.
+- Use **Screenshot Testing** to verify layouts across different size classes.

package/templates/mad-skills/references/advanced_performance.md

@@ -0,0 +1,52 @@
+# Advanced Performance Tools
+
+While standard performance optimization focuses on code efficiency, advanced tools help you optimize the "experience" of the app (startup, smoothness, battery).
+
+## 1. Baseline Profiles
+
+Baseline Profiles tell the Android Runtime (ART) which methods should be pre-compiled to machine code. This can improve app startup time and smooth scrolling by up to 30%.
+
+- **Generate**: Use the Benchmark library to record a "warmup profile".
+- **Distribute**: Include the profile in your AAB (Android App Bundle).
+
+## 2. Macrobenchmark Library
+
+Use Macrobenchmark to measure large-scale interactions:
+
+- **Startup Timing**: Cold, Warm, and Hot startup measurements.
+- **Frame Timing**: Measure jank during scrolling or complex animations.
+
+```kotlin
+@RunWith(AndroidJUnit4::class)
+class StartupBenchmark {
+    @get:Rule
+    val benchmarkRule = MacrobenchmarkRule()
+
+    @Test
+    fun startup() = benchmarkRule.measureRepeated(
+        packageName = "com.example.myapp",
+        metrics = listOf(StartupTimingMetric()),
+        iterations = 5,
+        startupMode = StartupMode.COLD
+    ) {
+        pressHome()
+        startActivityAndWait()
+    }
+}
+```
+
+## 3. App Startup Library
+
+The App Startup library provides a straightforward, performant way to initialize components at application startup. Use this instead of multiple `ContentProviders`, which slow down the app launch.
+
+## 4. Layout Inspector and Validation
+
+- **Live Edit**: See changes in real-time without building.
+- **Recomposition Counter**: Identify "dirty" components that recompose too often.
+- **Color Blindness Check**: Verify UI contrast and accessibility colors.
+
+## 5. APK Size Optimization
+
+- **R8/ProGuard**: Shrink, obfuscate, and optimize your code.
+- **Resource Shrinking**: Remove unused resources automatically.
+- **Dynamic Delivery**: Only deliver code/resources needed for the specific device configuration.

package/templates/mad-skills/references/advanced_ui.md

@@ -0,0 +1,64 @@
+# Advanced UI & Pro Techniques in Compose
+
+Take your Compose skills to the next level with complex animations, custom drawing, and specialized layouts.
+
+## 1. Advanced Animations
+
+Move beyond `AnimatedVisibility` to more fine-grained control.
+
+### `updateTransition`
+
+Manage multiple animation properties simultaneously that are linked to a single state change.
+
+```kotlin
+val transition = updateTransition(expanded, label = "cardExpansion")
+val color by transition.animateColor { isExpanded -> if (isExpanded) Red else Blue }
+val size by transition.animateDp { isExpanded -> if (isExpanded) 200.dp else 100.dp }
+```
+
+### `Animatable`
+
+For low-level, fire-and-forget animations or animations where you need a custom listener/trigger.
+
+```kotlin
+val alpha = remember { Animatable(0f) }
+LaunchedEffect(Unit) {
+    alpha.animateTo(1f, animationSpec = tween(1000))
+}
+```
+
+## 2. Custom Drawing with Canvas
+
+When standard components aren't enough, use the `Canvas` API.
+
+- **Draw Phase**: Drawing is highly efficient because it bypasses Layout and Composition.
+- **Access to Native Canvas**: You can drop down to `drawIntoCanvas` to use standard Android `android.graphics.Canvas` features.
+
+```kotlin
+Canvas(modifier = Modifier.size(100.dp)) {
+    drawCircle(color = Color.Blue, radius = size.minDimension / 2)
+    drawLine(color = Color.Black, start = Offset.Zero, end = Offset(size.width, size.height))
+}
+```
+
+## 3. Custom Layouts
+
+If `Row`, `Column`, and `Box` don't fit your needs, build a custom layout.
+
+- **`Layout` composable**: Measure children once, and place them in a 2D space.
+- **`SubcomposeLayout`**: Allows you to defer composition of some children until you know the constraints of others (used in `Scaffold` and `BoxWithConstraints`).
+
+## 4. Advanced Interactivity
+
+- **`PointerInput`**: Detect custom gestures like multi-touch, long-press with specific offsets, or custom drag-and-drop.
+- **LookaheadScope**: New in Compose, allows you to "look ahead" at where a layout *will* be to animate transitions smoothly between different layout configurations.
+
+## 5. Visual Effects
+
+- **`graphicsLayer`**: Applying renders effects like `blur`, `shadow`, `scale`, and `rotation` efficiently.
+- **Shaders**: Use `RuntimeShader` (Android AGSL) to create high-performance visual effects like glows, patterns, and distortions.
+
+## 6. Performance "Pro" Tips
+
+- **Avoid frequent state reads in Composition**: If a value changes 60 times per second, read it only in the **Draw** or **Layout** phase using lambda modifiers.
+- **Stability Monitoring**: Use the `compose-compiler-report` to identify unstable classes that are causing excessive recomposition.

package/templates/mad-skills/references/ai_ml.md

@@ -0,0 +1,38 @@
+# On-Device AI in Modern Android
+
+Integrating AI directly on the device ensures privacy, works offline, and reduces latency.
+
+## 1. Google AI Edge SDK
+
+The Google AI Edge SDK provides access to **Gemini Nano**, the smallest and most efficient model designed for on-device tasks.
+
+### Use Cases
+
+- **Summarization**: Summarizing long texts locally.
+- **Smart Reply**: Generating context-aware reply suggestions.
+- **Content safety**: Local filtering of sensitive content.
+
+## 2. ML Kit
+
+For specialized vision and NLP tasks, use ML Kit.
+
+- **Vision APIs**: Barcode scanning, Face detection, Object detection, OCR (Text Recognition).
+- **Natural Language APIs**: Language identification, Translation (offline), Smart Reply.
+
+## 3. Implementation Patterns
+
+Always handle AI operations asynchronously using Coroutines and monitor battery/thermal impact.
+
+```kotlin
+// Example: Text Recognition with ML Kit
+suspend fun recognizeText(image: InputImage): String {
+    val recognizer = TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
+    return recognizer.process(image).await().text
+}
+```
+
+## 4. Best Practices
+
+- **Fallback Strategy**: Always have a non-AI or cloud-based fallback if the device model is not supported.
+- **Model Management**: Download models only when needed (on Wi-Fi) to save user data.
+- **Privacy First**: Explicitly inform users when data is processed locally vs. in the cloud.

package/templates/mad-skills/references/architecture_di.md

@@ -0,0 +1,63 @@
+# Architecture and Dependency Injection in Modern Android Development
+
+Modern Android Development (MAD) follows a multi-layered architecture to ensure separation of concerns, scalability, and testability.
+
+## 1. The MAD Layered Architecture
+
+### UI Layer
+
+- **Composables**: Pure, stateless UI components.
+- **ViewModels**: Manage UI state and handle user events. ViewModels interact with the Domain Layer (Use Cases) or the Data Layer (Repositories).
+
+### Domain Layer (Optional)
+
+- **Use Cases**: Encapsulate complex business logic and enable reusability across ViewModels.
+- **Domain Models**: Pure Kotlin classes representing the data used by the business logic.
+
+### Data Layer
+
+- **Repositories**: Orchestrate data from multiple sources (Network, Local DB, Cache) and provide a clean API to the other layers.
+- **Data Sources**: Implementation details like Retrofit services (Network) or Room DAOs (Local).
+
+## 2. Unidirectional Data Flow (UDF)
+
+Data should flow in a single direction to maintain a predictable state:
+
+1. **State Flows Down**: Data travels from Repositories -> Use Cases -> ViewModels -> UI.
+2. **Events Flow Up**: User interactions travel from UI -> ViewModels -> Use Cases -> Repositories.
+
+Managing dependencies manually leads to tightly coupled code. Use DI frameworks to automate this.
+
+### Hilt (Recommended)
+
+Google's official wrapper around Dagger, optimized for Android.
+
+**ViewModel Injection:**
+
+```kotlin
+@HiltViewModel
+class UserViewModel @Inject constructor(
+    private val getUserUseCase: GetUserUseCase
+) : ViewModel() { ... }
+```
+
+### Koin
+
+A pure-Kotlin functional DI framework.
+
+**Configuring a Module:**
+
+```kotlin
+val appModule = module {
+    single<UserRepository> { UserRepositoryImpl(get()) }
+    factory { GetUserUseCase(get()) }
+    viewModel { UserViewModel(get()) }
+}
+```
+
+## 3. Best Practices
+
+- **Constructor Injection**: Always prefer constructor injection for better testability.
+- **Interface Segregation**: ViewModels and Use Cases should depend on Repository interfaces, not implementations.
+- **Scoped Objects**: Use `@ViewModelScoped` for objects that should live as long as the ViewModel.
+- **Single Source of Truth**: The Repository should be the only component that decides where data comes from.

package/templates/mad-skills/references/automation_cicd.md

@@ -0,0 +1,53 @@
+# CI/CD & Automation for Modern Android
+
+Automating the build, test, and release process is essential for maintaining high-quality Android applications in a team environment.
+
+## 1. GitHub Actions for Android
+
+Use GitHub Actions to run checks on every Pull Request.
+
+```yaml
+name: Android CI
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+          cache: gradle
+
+      - name: Run Lint
+        run: ./gradlew lintDebug
+
+      - name: Run Unit Tests
+        run: ./gradlew testDebugUnitTest
+```
+
+## 2. Automated Release with Fastlane
+
+Fastlane automates taking screenshots, managing signing certificates, and uploading APKs/Bundles to the Play Store.
+
+### Common `Fastfile` Pattern
+
+```ruby
+platform :android do
+  desc "Deploy a new version to the Google Play Track"
+  lane :deploy do
+    gradle(task: "bundle", build_type: "Release")
+    upload_to_play_store(track: 'internal')
+  end
+end
+```
+
+## 3. Best Practices
+
+- **Cache Dependencies**: Use caching in your CI YAML to speed up builds.
+- **Fail Fast**: Run lint and unit tests before long-running UI tests.
+- **Secrets Management**: Never commit signing keys; use GitHub Secrets or a vault.
+- **Parallel Testing**: Use Firebase Test Lab for running UI tests across many devices.

package/templates/mad-skills/references/clean_architecture.md

@@ -0,0 +1,80 @@
+# Clean Architecture in Modern Android
+
+Clean Architecture is a software design philosophy that promotes the separation of concerns, making the system easy to maintain, test, and adapt to changes.
+
+## 1. The Core Layers
+
+In Clean Architecture, layers are organized like an onion, with the dependency rule stating that **dependencies must only point inwards**.
+
+```mermaid
+graph TD
+    UI[UI Layer / Controllers] --> UseCase[Use Cases / Domain]
+    Data[Data Layer / Presenters] --> UseCase
+    UseCase --> Entity[Entities / Business Rules]
+    
+    subgraph "Inner Circles (Stable)"
+        Entity
+        UseCase
+    end
+    
+    subgraph "Outer Circles (Volatile)"
+        UI
+        Data
+    end
+```
+
+### Entities (Inner Circle)
+
+- PURE Kotlin/Java objects.
+- Business entities that encapsulate the most general and high-level rules.
+- Least likely to change when something external (UI, Database) changes.
+
+### Use Cases (Interactors)
+
+- Contains application-specific business logic.
+- Coordinates the flow of data to and from the entities.
+- Defines **what** the user can do (e.g., `GetProductListUseCase`, `AuthenticateUserUseCase`).
+
+### Interface Adapters
+
+- Converts data from the format most convenient for use cases and entities to the format most convenient for external agencies (UI, DB).
+- ViewModels (UI) and Repositories (Data) live here.
+
+## 2. The Dependency Rule
+
+The dependency rule is the most important part: **Source code dependencies can only point inwards**.
+
+- The `Domain` layer (Entities/Use Cases) must NEVER know about anything in the `Data` or `UI` layers.
+- We achieve this through **Dependency Inversion**: Use interfaces in the Domain layer that are implemented in the Data layer.
+
+## 3. Mapping Clean Architecture to MAD
+
+Modern Android Development (MAD) simplifies some Clean Architecture concepts for productivity:
+
+- **UI Layer**: (Presenters/ViewModels) + Jetpack Compose.
+- **Domain Layer**: (Use Cases). Optional but recommended for complex apps.
+- **Data Layer**: (Repositories + Data Sources like Room/Retrofit).
+
+## 4. Key Benefits
+
+- **Testability**: You can test the business logic without any UI or DB components.
+- **Independence**: The UI can change from XML to Compose without touching the core logic.
+- **Maintainability**: Clear boundaries prevent the emergence of "God Classes".
+
+## 5. Implementation Pattern
+
+```kotlin
+// Domain Layer
+class GetUserDetailUseCase(private val userRepository: UserRepository) {
+    suspend operator fun invoke(id: String): User = userRepository.getUser(id)
+}
+
+interface UserRepository {
+    suspend fun getUser(id: String): User
+}
+
+// Data Layer
+class UserRepositoryImpl(private val apiService: ApiService) : UserRepository {
+    override suspend fun getUser(id: String): User = apiService.fetchUser(id).toDomain()
+}
+```