@leejungkiin/awkit 1.0.7 → 1.0.9

package/skills/smali-to-kotlin/phase-3-build.md

@@ -0,0 +1,248 @@
+# 🔨 Phase 3: Implementation (Ground View — per feature)
+
+> **Zoom Level:** 3 — Code Implementation
+> **Goal:** Write actual, production-quality code for ONE feature.
+> **Input:** Approved Blueprint from Phase 2.
+> **Output:** Complete implementation files.
+
+---
+
+## ✅ PREREQUISITES
+
+Before writing ANY code, confirm:
+- [ ] Phase 0 App Map exists and is approved
+- [ ] Phase 1 Architecture Blueprint exists and is approved
+- [ ] Phase 2 Feature Blueprint exists for THIS feature and is approved
+- [ ] All contracts (interfaces, models, state) are defined in Blueprint
+
+---
+
+## 📋 Implementation Order (per feature)
+
+### 3.1: Domain Layer
+
+1. **Models** — data classes from Blueprint 2.2
+2. **Repository interfaces** — from Blueprint 2.3
+3. **UseCases** — implement invoke() with repository calls
+
+```kotlin
+class LoginUseCase @Inject constructor(
+    private val authRepository: AuthRepository
+) {
+    suspend operator fun invoke(email: String, password: String): Result<User> {
+        return authRepository.login(email, password)
+    }
+}
+```
+
+### 3.2: Data Layer
+
+1. **DTOs** — @Serializable data classes matching API JSON
+2. **API interfaces** — Retrofit with correct annotations
+3. **Room entities + DAOs** (if applicable)
+4. **DataStore** setup (if applicable)
+5. **Repository implementation** — offline-first pattern:
+
+```kotlin
+class AuthRepositoryImpl @Inject constructor(
+    private val api: AuthApi,
+    private val tokenStore: TokenDataStore
+) : AuthRepository {
+    
+    override suspend fun login(email: String, password: String): Result<User> {
+        return runCatching {
+            val response = api.login(LoginRequest(email, password))
+            tokenStore.saveToken(response.accessToken)
+            response.user.toDomain()
+        }
+    }
+    
+    override fun isLoggedIn(): Flow<Boolean> {
+        return tokenStore.tokenFlow.map { it.isNotEmpty() }
+    }
+}
+```
+
+### 3.3: DI Module
+
+```kotlin
+@Module
+@InstallIn(SingletonComponent::class)
+abstract class RepositoryModule {
+    @Binds
+    abstract fun bindAuthRepository(impl: AuthRepositoryImpl): AuthRepository
+}
+```
+
+### 3.4: ViewModel
+
+Implement using UiState + Events from Blueprint:
+
+```kotlin
+@HiltViewModel
+class LoginViewModel @Inject constructor(
+    private val loginUseCase: LoginUseCase
+) : ViewModel() {
+
+    private val _uiState = MutableStateFlow(LoginUiState())
+    val uiState = _uiState.asStateFlow()
+
+    private val _events = MutableSharedFlow<LoginEvent>()
+    val events = _events.asSharedFlow()
+
+    fun onAction(action: LoginAction) {
+        when (action) {
+            is LoginAction.UpdateEmail -> _uiState.update { it.copy(email = action.email) }
+            is LoginAction.UpdatePassword -> _uiState.update { it.copy(password = action.password) }
+            LoginAction.TogglePasswordVisibility -> _uiState.update { it.copy(isPasswordVisible = !it.isPasswordVisible) }
+            LoginAction.Submit -> login()
+        }
+    }
+
+    private fun login() {
+        viewModelScope.launch {
+            _uiState.update { it.copy(isLoading = true, error = null) }
+            loginUseCase(uiState.value.email, uiState.value.password)
+                .onSuccess { user -> _events.emit(LoginEvent.NavigateToHome(user)) }
+                .onFailure { e -> _uiState.update { it.copy(error = e.message, isLoading = false) } }
+        }
+    }
+}
+```
+
+### 3.5: Compose Screen
+
+```kotlin
+@Composable
+fun LoginScreen(
+    viewModel: LoginViewModel = hiltViewModel(),
+    onNavigateToHome: () -> Unit
+) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+
+    LaunchedEffect(Unit) {
+        viewModel.events.collect { event ->
+            when (event) {
+                is LoginEvent.NavigateToHome -> onNavigateToHome()
+                is LoginEvent.ShowSnackbar -> { /* snackbar */ }
+            }
+        }
+    }
+
+    // Compose UI from Blueprint wireframe
+    Scaffold { padding ->
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(padding)
+                .padding(24.dp),
+            horizontalAlignment = Alignment.CenterHorizontally
+        ) {
+            // Logo, TextFields, Button — matching wireframe
+        }
+    }
+}
+```
+
+### 3.6: Resource Extraction (On-Demand)
+
+**ONLY** extract resources used by this screen:
+- Drawables referenced in layout XML
+- Strings used in this Activity's Smali
+- Colors and Dimens for this screen
+
+```bash
+# Find drawables used in layout
+grep -o '@drawable/[a-z_]*' [apktool_dir]/res/layout/activity_login.xml | sort -u
+
+# Find strings used in Activity smali
+grep 'const-string.*R.string' [apktool_dir]/smali/.../LoginActivity.smali
+```
+
+---
+
+## 🔒 CRYPTO UTILS (Special Handling)
+
+If the feature involves encryption/hashing:
+
+1. **Read Smali carefully** — exact algorithm, padding, encoding
+2. **Implement in Kotlin** — preserve exact input/output
+3. **Unit test IMMEDIATELY** — with known pairs from original app
+
+```kotlin
+object CryptoUtils {
+    fun hashMd5(input: String): String {
+        val md = MessageDigest.getInstance("MD5")
+        return md.digest(input.toByteArray())
+            .joinToString("") { "%02x".format(it) }
+    }
+}
+
+// TEST (mandatory)
+class CryptoUtilsTest {
+    @Test
+    fun `md5 matches original app output`() {
+        // Capture known pairs from running original app
+        assertEquals("expected_hash", CryptoUtils.hashMd5("known_input"))
+    }
+}
+```
+
+> ⚠️ Crypto functions MUST produce identical output. Any mismatch breaks server communication.
+
+---
+
+## ✅ Checkpoint (After each feature)
+
+```markdown
+## ✅ Feature Complete: [Feature Name]
+
+### Files created:
+- domain/model/User.kt
+- domain/repository/AuthRepository.kt
+- domain/usecase/LoginUseCase.kt
+- data/remote/api/AuthApi.kt
+- data/remote/dto/LoginRequest.kt, LoginResponse.kt
+- data/repository/AuthRepositoryImpl.kt
+- presentation/screens/auth/LoginScreen.kt
+- presentation/screens/auth/LoginViewModel.kt
+- presentation/screens/auth/LoginUiState.kt
+
+### Resources extracted:
+- [only what was needed]
+
+### Tests:
+- [ ] Crypto utils verified
+- [ ] API contract matches original
+
+### ⏭️ Next Feature: [Name]
+→ Return to Phase 2 (Blueprint) for this feature
+```
+
+---
+
+## 🔄 Loop
+
+```
+Phase 2 (Blueprint for Feature X) → Phase 3 (Build Feature X) → Checkpoint
+    ↓
+Phase 2 (Blueprint for Feature Y) → Phase 3 (Build Feature Y) → Checkpoint
+    ↓
+... (repeat for all features from Architecture Build Order)
+    ↓
+Final: Parity Check & Quality Gate
+```
+
+---
+
+## ✅ Final Parity Check (After all features)
+
+1. **API Parity** — all endpoints match (headers, body, encoding)
+2. **Data Parity** — crypto/hash output identical
+3. **UI Parity** — screen-by-screen comparison
+4. **Edge Cases** — empty states, errors, offline
+5. **Build & Test** — `./gradlew assembleDebug && ./gradlew test && ./gradlew lint`
+
+---
+
+*Phase 3: Implementation — One feature at a time, guided by Blueprint*

package/skills/smali-to-kotlin/templates/app-map.md

@@ -0,0 +1,101 @@
+# 🗺️ App Map: [App Name]
+
+**Generated:** [Date]
+**Source:** [Apktool dir path]
+
+---
+
+## 📱 Identity
+
+| Property | Value |
+|----------|-------|
+| Package | [com.example.app] |
+| App Name | [Display Name] |
+| Min SDK | [value] |
+| Target SDK | [value] |
+| Screens | [count] Activities |
+| Services | [count] |
+| Receivers | [count] |
+| Providers | [count] |
+
+---
+
+## 🧭 Screen Flow
+
+```
+┌──────────┐    ┌──────────┐    ┌──────────────┐
+│  Splash  │───→│  Login   │───→│  Main Tab    │
+└──────────┘    └──────────┘    ├──────────────┤
+                                 │ Tab 1: Home  │
+                                 │ Tab 2: ...   │
+                                 │ Tab 3: ...   │
+                                 └──────────────┘
+                                       │
+                                 ┌─────┴─────┐
+                                 │  Detail   │
+                                 │  ...      │
+                                 └───────────┘
+```
+
+*Or use Mermaid:*
+```mermaid
+graph LR
+    Splash --> Login
+    Login --> MainTab
+    MainTab --> Home
+    MainTab --> Tab2
+    MainTab --> Tab3
+    Home --> Detail
+```
+
+---
+
+## 📦 Library Landscape
+
+### ✅ Reuse (add to build.gradle)
+| Library | Detected Package | Latest Version | Action |
+|---------|-----------------|----------------|--------|
+
+### 🔄 Replace (legacy → modern)
+| Old Library | Detected Package | Modern Replacement |
+|-------------|-----------------|-------------------|
+
+### 🔵 Firebase / Google SDKs
+| SDK | Detected | Action |
+|-----|----------|--------|
+
+### 📱 Native (.so) — Keep
+| File | Architecture | Notes |
+|------|-------------|-------|
+
+### 🏷️ App Code (rebuild in Kotlin)
+| Package | Estimated Module |
+|---------|-----------------|
+
+### ❓ Unknown (needs investigation)
+| Package | Path | Possible Library |
+|---------|------|-----------------|
+
+---
+
+## 📊 Complexity Estimate
+
+| Area | Rating | Notes |
+|------|--------|-------|
+| Data Layer | ●●●○○ | [N] APIs, [N] local DB, [N] DataStores |
+| Core Logic | ●●○○○ | [N] crypto utils, [N] formatters |
+| UI Screens | ●●●●○ | [N] screens, [N] complex layouts |
+| SDK Integration | ●●○○○ | [N] third-party, [N] native libs |
+
+---
+
+## 🔍 Key Observations
+
+- [Notable patterns: obfuscation level, unusual architecture, etc.]
+- [Security observations: certificate pinning, root detection, etc.]
+- [Risks: native libs without source, proprietary SDKs, etc.]
+
+---
+
+> **Next:** Anh review map này, có gì cần điều chỉnh không?
+> → OK → Proceed to Phase 1 (Architecture Design)

package/skills/smali-to-kotlin/templates/architecture.md

@@ -0,0 +1,142 @@
+# 🏗️ Architecture Blueprint: [App Name]
+
+**Generated:** [Date]
+**Based on:** App Map v[date]
+
+---
+
+## 📐 Layer Map
+
+```
+┌─────────────────────────────────────┐
+│ Presentation                        │
+│ ├── screens/ ([N] screens)          │
+│ ├── navigation/ (NavGraph + Routes) │
+│ ├── theme/ (Material 3 Theme)      │
+│ └── components/ (Shared UI)        │
+├─────────────────────────────────────┤
+│ Domain                              │
+│ ├── model/ ([N] business models)    │
+│ ├── repository/ ([N] interfaces)   │
+│ └── usecase/ ([N] use cases)        │
+├─────────────────────────────────────┤
+│ Data                                │
+│ ├── remote/ ([N] API services)     │
+│ ├── local/ (Room DB, DataStore)    │
+│ └── repository/ ([N] impls)        │
+├─────────────────────────────────────┤
+│ DI (Hilt)                           │
+│ └── modules/ (Network, DB, Repo)   │
+└─────────────────────────────────────┘
+```
+
+---
+
+## 🗂️ Feature → File Mapping
+
+| Feature | Domain Model | Repository | UseCase | Screen(s) | ViewModel |
+|---------|-------------|-----------|---------|-----------|-----------|
+| Auth | User, Token | AuthRepo | LoginUC, RegisterUC | Login, Register | AuthVM |
+| Home | [Model] | [Repo] | [UC] | Home | HomeVM |
+| Profile | [Model] | [Repo] | [UC] | Profile, Edit | ProfileVM |
+| Settings | [Model] | [Repo] | [UC] | Settings | SettingsVM |
+| ... | ... | ... | ... | ... | ... |
+
+---
+
+## 🌐 API Endpoints
+
+| # | Method | Endpoint | Auth | Notes |
+|---|--------|----------|------|-------|
+| 1 | POST | /auth/login | No | JWT response |
+| 2 | GET | /users/me | Bearer | User profile |
+| ... | ... | ... | ... | ... |
+
+**Base URL:** `[extracted from Smali]`
+**Auth Type:** [Bearer token / API key / Custom]
+
+---
+
+## 💾 Data Schema
+
+| Model | Key Fields | Source | Storage |
+|-------|-----------|--------|---------|
+| User | id, name, email, avatar | API + Local | Room |
+| Settings | theme, lang, notif | Local only | DataStore |
+| ... | ... | ... | ... |
+
+---
+
+## 📁 Project Structure
+
+```
+app/src/main/java/[package]/
+├── App.kt
+├── di/
+│   ├── AppModule.kt
+│   ├── NetworkModule.kt
+│   └── DatabaseModule.kt
+├── data/
+│   ├── remote/
+│   │   ├── api/
+│   │   ├── dto/
+│   │   └── interceptor/
+│   ├── local/
+│   │   ├── db/
+│   │   ├── dao/
+│   │   ├── entity/
+│   │   └── datastore/
+│   └── repository/
+├── domain/
+│   ├── model/
+│   ├── repository/
+│   └── usecase/
+├── presentation/
+│   ├── navigation/
+│   ├── theme/
+│   ├── components/
+│   └── screens/
+│       ├── splash/
+│       ├── auth/
+│       ├── home/
+│       └── .../
+└── util/
+```
+
+---
+
+## 🔢 Build Order
+
+| # | Phase | Scope | Complexity |
+|---|-------|-------|-----------|
+| 1 | 🟢 Setup | Project + DI skeleton + Theme | Low |
+| 2 | 🟢 Models | Domain data classes | Low |
+| 3 | 🟡 Data | API + Room + DataStore | Medium |
+| 4 | 🟡 Utils | Crypto, formatters (parity test!) | Medium |
+| 5 | 🔴 Feature: [First] | Blueprint → Build | High |
+| 6 | 🔴 Feature: [Second] | Blueprint → Build | High |
+| ... | ... | ... | ... |
+| N | 🔴 Final | Parity check + QA | High |
+
+**Suggested first feature:** [Name] — because [reason]
+
+---
+
+## 🔧 Tech Stack Decisions
+
+| Decision | Choice | Rationale |
+|----------|--------|-----------|
+| UI Framework | Jetpack Compose + Material 3 | Modern, declarative |
+| DI | Hilt | Standard Android DI |
+| Network | Retrofit + OkHttp | [Keep/Replace based on scan] |
+| JSON | Kotlin Serialization | Type-safe, KMP ready |
+| Image Loading | [Coil / Keep Glide] | [reason] |
+| Local DB | Room | [reason] |
+| Preferences | DataStore | Replaces SharedPreferences |
+| Async | Coroutines + Flow | Modern concurrency |
+
+---
+
+> **Next:** Anh muốn bắt đầu từ feature nào?
+> Em suggest: **[Feature]** vì [reason].
+> → Pick feature → Phase 2 (Blueprint)

package/skills/smali-to-kotlin/templates/blueprint.md

@@ -0,0 +1,145 @@
+# 📐 Feature Blueprint: [Feature Name]
+
+**Generated:** [Date]
+**Architecture:** [App Name] v[date]
+**Feature:** [Feature Name]
+
+---
+
+## 🔍 Smali Analysis Summary
+
+| Item | Value |
+|------|-------|
+| Files analyzed | [list of Smali files] |
+| Classes found | [count] |
+| API calls detected | [count] |
+| Local storage | [types: SharedPrefs, SQLite, etc.] |
+
+### Key Observations
+- [Pattern 1: e.g., "Uses MD5 + Base64 for password hashing"]
+- [Pattern 2: e.g., "Token stored in SharedPreferences key 'auth_token'"]
+- [Pattern 3: e.g., "Custom header 'X-App-Key' in all requests"]
+
+---
+
+## 📦 Domain Models
+
+```kotlin
+data class [Model](
+    val field1: Type,
+    val field2: Type,
+    // ...
+)
+```
+
+---
+
+## 📡 API Contract
+
+```kotlin
+interface [Feature]Api {
+    @[METHOD]("[endpoint]")
+    suspend fun [method](@Body request: [Request]): [Response]
+}
+```
+
+**Request/Response DTOs:**
+```kotlin
+@Serializable
+data class [Request](/* fields */)
+
+@Serializable
+data class [Response](/* fields */)
+```
+
+---
+
+## 🗄️ Repository Contract
+
+```kotlin
+interface [Feature]Repository {
+    suspend fun [method1](...): Result<[Type]>
+    fun [method2](): Flow<[Type]>
+}
+```
+
+---
+
+## 🧩 UseCase Signatures
+
+```kotlin
+class [Action]UseCase(private val repo: [Feature]Repository) {
+    suspend operator fun invoke(...): Result<[Type]>
+}
+```
+
+---
+
+## 🎨 UI State Design
+
+```kotlin
+// State
+data class [Screen]UiState(
+    val field1: Type = default,
+    val isLoading: Boolean = false,
+    val error: String? = null
+)
+
+// One-time events
+sealed interface [Screen]Event {
+    data class NavigateTo[Next](/* params */) : [Screen]Event
+    data class ShowSnackbar(val message: String) : [Screen]Event
+}
+
+// User actions
+sealed interface [Screen]Action {
+    data class Update[Field](val value: Type) : [Screen]Action
+    data object Submit : [Screen]Action
+}
+```
+
+---
+
+## 🖼️ Screen Wireframe
+
+```
+┌────────────────────────┐
+│                        │
+│    [Layout sketch]     │
+│                        │
+└────────────────────────┘
+
+Behaviors:
+- [Interaction 1]
+- [Interaction 2]
+- [Error handling]
+- [Navigation on success]
+```
+
+---
+
+## 📁 Files to Create
+
+| File | Layer | Type |
+|------|-------|------|
+| [Model].kt | domain/model | Data class |
+| [Feature]Repository.kt | domain/repository | Interface |
+| [Action]UseCase.kt | domain/usecase | Class |
+| [Feature]Api.kt | data/remote/api | Retrofit interface |
+| [DTOs].kt | data/remote/dto | Serializable |
+| [Feature]RepositoryImpl.kt | data/repository | Implementation |
+| [Screen]Screen.kt | presentation/screens | Composable |
+| [Screen]ViewModel.kt | presentation/screens | ViewModel |
+
+---
+
+## 🔗 Dependencies
+
+- **Depends on:** [other features/modules this needs]
+- **Depended by:** [features that need this]
+
+---
+
+> **Next:** Anh xem contracts ổn không?
+> → OK → Phase 3 (Implementation)
+> → Adjust → Update blueprint