@leejungkiin/awkit 1.0.4 → 1.0.6

package/VERSION

@@ -1 +1 @@
-1.0.2
+1.0.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@leejungkiin/awkit",
-  "version": "1.0.4",
-  "description": "AWKit v1.0.4 — Antigravity Workflow Kit. Unified AI agent orchestration system.",
+  "version": "1.0.6",
+  "description": "AWKit v1.0.6 — Antigravity Workflow Kit. Unified AI agent orchestration system.",
   "main": "bin/awk.js",
   "bin": {
     "awkit": "bin/awk.js",
@@ -17,13 +17,7 @@
     "harvest-dry": "node scripts/harvest.js --dry-run"
   },
   "keywords": [
-    "awkit",
-    "awk",
-    "antigravity-workflow-kit",
-    "ai-agent",
-    "workflow",
-    "gemini",
-    "claude"
+    "awkit"
   ],
   "author": "Kien AI",
   "license": "MIT",

package/workflows/mobile/reverse-android-build.md

@@ -1,219 +1,169 @@
 ---
-description: 🏗️ RE Android Phase 2 — Data Layer, Utils, UI, SDK Integration & Parity Check
+description: 🔨 RE Android Phase 2+3 — Per-feature Blueprint → Implementation → Parity Check
 parent: reverse-android
 ---
 
-# /re-android-build — Build & Verify
+# /re-android-build — Blueprint & Build (Per Feature)
 
-> **Parent:** [`/reverse-android`](reverse-android.md) → Step 2-6
-> **Prerequisite:** Hoàn thành [`/re-android-scan`](reverse-android-scan.md)
-> **Skill:** `smali-to-kotlin` | **Smali Guide:** `skills/smali-to-kotlin/smali-reading-guide.md`
+> **Parent:** [`/reverse-android`](reverse-android.md) → Phase 2+3
+> **Prerequisite:** Completed Architecture from [`/re-android-design`](reverse-android-design.md)
+> **Skill:** `smali-to-kotlin` → `phase-2-blueprint.md` + `phase-3-build.md`
 
 ---
 
-## 💾 Step 2: Data Layer Reconstruction
+## 🔄 Feature Loop
 
-> **Input:** Smali files cho network, models, database logic
-
-### 2.1: Network Layer → Retrofit interfaces
-
-```kotlin
-interface UserApi {
-    @GET("users/{id}")
-    suspend fun getUser(@Path("id") id: String): UserDto
-
-    @POST("auth/login")
-    suspend fun login(@Body request: LoginRequest): TokenDto
-}
 ```
-
-### 2.2: DTOs (Kotlin Serialization)
-
-```kotlin
-@Serializable
-data class UserDto(
-    @SerialName("user_id") val userId: String,
-    @SerialName("full_name") val fullName: String,
-    @SerialName("email") val email: String,
-)
+For each feature (from Architecture Build Order):
+    Phase 2: Blueprint (Zoom 2 — signatures only)
+        ↓ [User approves]
+    Phase 3: Implementation (Zoom 3 — full code)
+        ↓ [Checkpoint]
+    → Next feature
 ```
 
-### 2.3: Room Database (nếu có local DB)
-
-- Entity với `@Entity` + `@PrimaryKey`
-- DAO với `@Dao` + `Flow<>` return types
-- `OnConflictStrategy.REPLACE` cho upsert
-
-### 2.4: Repository Pattern
-
-- Domain: `interface UserRepository` (Flows + Results)
-- Data: `UserRepositoryImpl @Inject constructor(api, dao)` — offline-first
-
-### ✅ Checkpoint Step 2
-
 ---
 
-## 🧮 Step 3: Core Logic & Utils
+## 📐 Phase 2: Feature Blueprint (Zoom 2)
 
-> **CRITICAL:** Output phải match 100% với app gốc
+> **Output:** Contracts, interfaces, state design. **Signatures only, no bodies.**
 
-### 3.1: Nhận diện từ Smali
+### 2.1: Deep Smali Reading
 
-```
-javax/crypto/Cipher       → AES/DES encryption
-java/security/MessageDigest → MD5/SHA hashing
-android/util/Base64        → Base64 encoding
-Custom XOR/shift loops     → Custom obfuscation
-```
+Read Smali files for the chosen feature. Extract:
+- Class hierarchy, fields, method signatures
+- String constants (URLs, keys, messages)
+- Control flow → business rules (document, don't code)
 
-### 3.2: Kotlin objects
+### 2.2: Contracts
+
+Define for this feature:
 
 ```kotlin
-object CryptoUtils {
-    fun hashMd5(input: String): String {
-        val md = MessageDigest.getInstance("MD5")
-        return md.digest(input.toByteArray())
-            .joinToString("") { "%02x".format(it) }
-    }
-    fun encryptAes(data: String, key: String): String { /* from Smali */ }
+// Domain Model
+data class [Model](val field1: Type, ...)
+
+// Repository Interface
+interface [Feature]Repository {
+    suspend fun [method](...): Result<[Type]>
+    fun [stream](): Flow<[Type]>
 }
-```
 
-### 3.3: Unit Test verification (BẮT BUỘC cho crypto)
+// API Interface
+interface [Feature]Api {
+    @[METHOD]("[endpoint]")
+    suspend fun [method](...): [Response]
+}
 
-```kotlin
-class CryptoUtilsTest {
-    @Test
-    fun `md5 hash matches original`() {
-        assertEquals("expected_hash", CryptoUtils.hashMd5("test_input"))
-    }
+// UseCase
+class [Action]UseCase(repo: [Feature]Repository) {
+    suspend operator fun invoke(...): Result<[Type]> // TODO()
 }
 ```
 
-### ✅ Checkpoint Step 3
+### 2.3: UI State Design
 
----
-
-## 🎨 Step 4: UI & ViewModel (Per Screen — Loop)
+```kotlin
+data class [Screen]UiState(
+    val field: Type = default,
+    val isLoading: Boolean = false,
+    val error: String? = null
+)
 
-> **Input:** `res/layout/*.xml` + Activity/Fragment Smali
-> **Lặp lại** cho MỌI màn hình từ Step 1
+sealed interface [Screen]Event { /* navigation, snackbar */ }
+sealed interface [Screen]Action { /* user interactions */ }
+```
 
-### 4.0: Thứ tự ưu tiên
+### 2.4: Wireframe + File List
 
-1. SplashScreen → 2. Auth → 3. Home → 4. Detail → 5. Settings/Profile
+ASCII wireframe + list of files to create.
 
-### 4.1: Resource Extraction (On-Demand only)
+### ✅ Blueprint Gate
 
-Chỉ copy resources cho màn hình hiện tại: drawables, strings, colors, dimens, fonts.
+```
+"📐 Blueprint cho [Feature] xong. Anh xem OK không? → Em bắt đầu code."
+```
 
-### 4.2: XML Layout → Compose
+---
 
-Pattern cho mỗi screen:
+## 🔨 Phase 3: Implementation (Zoom 3)
 
-```kotlin
-@Composable
-fun [Screen]Screen(
-    viewModel: [Screen]ViewModel = hiltViewModel(),
-    onNavigateTo[Next]: () -> Unit
-) {
-    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
-    // LaunchedEffect for events
-    // Scaffold with content
-}
-```
+> **Output:** Full production-quality Kotlin code for THIS feature only.
 
-### 4.3: ViewModel Pattern
+### 3.1: Domain Layer
 
-```kotlin
-@HiltViewModel
-class [Screen]ViewModel @Inject constructor(
-    private val useCase: [Feature]UseCase
-) : ViewModel() {
-    private val _uiState = MutableStateFlow([Screen]UiState())
-    val uiState = _uiState.asStateFlow()
-    
-    private val _events = MutableSharedFlow<[Screen]Event>()
-    val events = _events.asSharedFlow()
-}
+- Models (data classes from Blueprint)
+- Repository interfaces (from Blueprint)
+- UseCases (implement invoke with repo calls)
 
-data class [Screen]UiState(val isLoading: Boolean = false, val error: String? = null)
-sealed interface [Screen]Event { /* navigation, snackbar */ }
-```
+### 3.2: Data Layer
 
-### ✅ Checkpoint Step 4 (Per Screen)
+- DTOs (@Serializable)
+- Retrofit API interface
+- Room entities + DAOs (if applicable)
+- Repository implementation (offline-first)
 
-> **Loop:** Quay lại 4.0 cho screen tiếp. Hết screen → Step 5.
+### 3.3: DI Module
 
----
+- Hilt @Module with @Binds for repository
 
-## 📦 Step 5: SDK & Native Library Integration
+### 3.4: ViewModel
 
-> **Input:** Library Report từ Step 0
+- @HiltViewModel with StateFlow + SharedFlow
+- Implement onAction() handler from Blueprint actions
 
-### 5.1: Native Libraries (.so) → JNI Bridge
+### 3.5: Compose Screen
 
-```kotlin
-class NativeBridge {
-    companion object { init { System.loadLibrary("name") } }
-    external fun nativeMethod(param: String): ByteArray
-}
-```
+- Collect state with collectAsStateWithLifecycle()
+- UI from wireframe
+- LaunchedEffect for events
 
-### 5.2: Application class
+### 3.6: Resource Extraction (On-Demand only)
 
-```kotlin
-@HiltAndroidApp
-class App : Application() {
-    override fun onCreate() { super.onCreate(); setupTimber(); setupFirebase() }
-}
+```bash
+# Only resources for THIS screen
+grep -o '@drawable/[a-z_]*' [apktool_dir]/res/layout/activity_[screen].xml | sort -u
 ```
 
-### 5.3: Hilt DI Modules
+### 🔒 Crypto Utils (Special)
 
-- `NetworkModule`: OkHttpClient + Retrofit + Interceptors
-- `DatabaseModule`: Room database + DAOs
-- `RepositoryModule`: Bind implementations
-
-### ✅ Checkpoint Step 5
-
----
+If feature involves crypto/hashing:
+1. Read Smali carefully (exact algorithm)
+2. Implement in Kotlin
+3. Unit test IMMEDIATELY with known pairs
 
-## ✅ Step 6: Parity Check & Quality Gate
+> ⚠️ Crypto MUST produce identical output to original app.
 
-### 6.1: Edge Case checklist (từ Smali branches)
+### ✅ Feature Checkpoint
 
 ```markdown
-- [ ] Login empty/invalid input
-- [ ] Network timeout/offline
-- [ ] Empty list states
-- [ ] Null server responses
-- [ ] App lifecycle (bg/fg)
-```
-
-### 6.2: API Parity
+## ✅ Feature Complete: [Name]
 
-- [ ] Base URL, headers, body format matches
-- [ ] Response parsing correct
-- [ ] Error handling matches
+### Files created: [list]
+### Resources extracted: [only needed]
+### Tests: [crypto verified? API matches?]
 
-### 6.3: Data Parity
+### ⏭️ Next Feature: [Name]
+→ Return to Phase 2 (Blueprint) for next feature
+```
 
-- [ ] Encryption/hash output matches
-- [ ] Date formatting matches
-- [ ] Local storage works correctly
+---
 
-### 6.4: Build & Test
+## ✅ Final Parity Check (After ALL features)
 
-```bash
-./gradlew assembleDebug && ./gradlew test && ./gradlew lint
-```
+### Checklist
+- [ ] API Parity — all endpoints match (headers, body, encoding)
+- [ ] Data Parity — crypto/hash output identical
+- [ ] UI Parity — screen-by-screen comparison
+- [ ] Edge Cases — empty states, errors, offline, lifecycle
+- [ ] Build & Test: `./gradlew assembleDebug && ./gradlew test && ./gradlew lint`
 
 ### 🎉 Final Summary
 
 ```markdown
-## Complete!
-- Screens: [count] | Libs reused: [count] | Replaced: [count]
+## ✅ Reverse Engineering Complete!
+- Screens: [count] | Features: [count]
+- Libs reused: [count] | Replaced: [count]
 - Tests: [pass/fail] | Lint: [pass/warnings]
 
 ⏭️ Next: /test → /deploy → /code-janitor
@@ -224,9 +174,9 @@ class App : Application() {
 ## 🔗 Related
 
 - **Parent:** [`/reverse-android`](reverse-android.md)
-- **Previous:** [`/re-android-scan`](reverse-android-scan.md) (Step 0-1)
-- **Smali Guide:** `skills/smali-to-kotlin/smali-reading-guide.md`
+- **Previous:** [`/re-android-design`](reverse-android-design.md) (Phase 1)
+- **Skill:** `smali-to-kotlin` → `phase-2-blueprint.md` + `phase-3-build.md`
 
 ---
 
-*re-android-build v2.0.0 — Phase 2: Build & Verify*
+*re-android-build v3.0.0 — Phase 2+3: Blueprint & Build*

package/workflows/mobile/reverse-android-design.md

@@ -0,0 +1,136 @@
+---
+description: 🏗️ RE Android Phase 1 — Architecture Design (NO CODE BODIES)
+parent: reverse-android
+---
+
+# /re-android-design — Architecture Blueprint
+
+> **Parent:** [`/reverse-android`](reverse-android.md) → Phase 1
+> **Prerequisite:** Completed App Map from [`/re-android-discover`](reverse-android-discover.md)
+> **Skill:** `smali-to-kotlin` → `phase-1-architecture.md`
+> **Zoom Level:** 1 — District View
+> **Output:** Architecture Blueprint (diagrams, tables, NO CODE BODIES)
+
+---
+
+## ⛔ ZOOM 1 RULE
+
+```
+This workflow produces NO CODE BODIES.
+Allowed: Architecture diagrams, layer maps, feature tables, file paths, API endpoint lists.
+Allowed: build.gradle.kts plugin/dependency declarations (declaration only).
+If you are about to write a function body → STOP → wrong zoom level.
+```
+
+---
+
+## 📐 Step 1: Layer Design
+
+Design Clean Architecture layers based on App Map:
+
+```
+┌─────────────────────────────────────┐
+│ Presentation                        │
+│ ├── screens/ ([N] screens)          │
+│ ├── navigation/ (NavGraph + Routes) │
+│ ├── theme/ (Material 3)            │
+│ └── components/ (Shared UI)        │
+├─────────────────────────────────────┤
+│ Domain                              │
+│ ├── model/ ([N] models)             │
+│ ├── repository/ ([N] interfaces)   │
+│ └── usecase/ ([N] use cases)        │
+├─────────────────────────────────────┤
+│ Data                                │
+│ ├── remote/ ([N] API services)     │
+│ ├── local/ (Room, DataStore)       │
+│ └── repository/ (implementations)  │
+├─────────────────────────────────────┤
+│ DI (Hilt)                           │
+│ └── modules/ (Network, DB, Repo)   │
+└─────────────────────────────────────┘
+```
+
+## 📋 Step 2: Feature → File Mapping
+
+Map mỗi feature tới Clean Architecture components:
+
+| Feature | Domain Model | Repository | UseCase | Screen(s) | ViewModel |
+|---------|-------------|-----------|---------|-----------|-----------|
+
+## 🌐 Step 3: API Endpoint Inventory
+
+Trích xuất TẤT CẢ API endpoints từ Smali:
+
+| # | Method | Endpoint | Auth | Notes |
+|---|--------|----------|------|-------|
+
+**Base URL:** `[from Smali const-string]`
+
+## 💾 Step 4: Data Schema
+
+| Model | Key Fields | Source | Storage |
+|-------|-----------|--------|---------|
+
+## 📁 Step 5: Project Structure
+
+```
+app/src/main/java/[package]/
+├── App.kt
+├── di/
+├── data/remote/ + data/local/ + data/repository/
+├── domain/model/ + domain/repository/ + domain/usecase/
+├── presentation/navigation/ + screens/ + theme/
+└── util/
+```
+
+## 🔢 Step 6: Build Order
+
+| # | Phase | Scope | Complexity |
+|---|-------|-------|-----------|
+| 1 | 🟢 Setup | Project + DI + Theme | Low |
+| 2 | 🟢 Models | Domain data classes | Low |
+| 3 | 🟡 Data | API + Room + DataStore | Medium |
+| 4 | 🟡 Utils | Crypto, formatters | Medium |
+| 5 | 🔴 Features | Per-feature Blueprint→Build | High |
+| N | 🔴 Final | Parity check | High |
+
+## 🔧 Step 7: Tech Stack Confirmation
+
+| Decision | Choice | Rationale |
+|----------|--------|-----------|
+| UI | Jetpack Compose + M3 | Modern |
+| DI | Hilt | Standard |
+| ... | ... | ... |
+
+---
+
+## 📊 Output: Architecture Blueprint
+
+Sử dụng template từ `skills/smali-to-kotlin/templates/architecture.md`.
+
+---
+
+## ✅ Gate: Chuyển sang Phase 2
+
+```
+"🏗️ Architecture Blueprint xong!
+Anh muốn bắt đầu từ feature nào?
+Em suggest: [Feature X] vì [reason]."
+
+→ User picks feature → /re-android-build (Phase 2: Blueprint for that feature)
+→ User wants changes → adjust architecture
+```
+
+---
+
+## 🔗 Related
+
+- **Previous:** [`/re-android-discover`](reverse-android-discover.md) (Phase 0)
+- **Next:** [`/re-android-build`](reverse-android-build.md) (Phase 2+3)
+- **Parent:** [`/reverse-android`](reverse-android.md)
+- **Skill:** `skills/smali-to-kotlin/phase-1-architecture.md`
+
+---
+
+*re-android-design v3.0.0 — Phase 1: Architecture Blueprint*

package/workflows/mobile/reverse-android-discover.md

@@ -0,0 +1,150 @@
+---
+description: 🗺️ RE Android Phase 0 — Discovery & App Map (NO CODE output)
+parent: reverse-android
+---
+
+# /re-android-discover — Discovery & App Map
+
+> **Parent:** [`/reverse-android`](reverse-android.md) → Phase 0
+> **Skill:** `smali-to-kotlin` → `phase-0-discovery.md`
+> **Zoom Level:** 0 — Satellite View
+> **Output:** App Map (diagrams, tables, NO CODE)
+
+---
+
+## ⛔ ZOOM 0 RULE
+
+```
+This workflow produces NO CODE output.
+Only: diagrams, tables, bullet lists, bash scan commands.
+If you are about to write Kotlin code → STOP → you are at wrong zoom level.
+```
+
+---
+
+## 📦 Step 0: Library Scanner
+
+> Nhận diện toàn bộ thư viện **trước khi làm bất kỳ thứ gì**.
+
+### 0.1: Quét structure
+
+```bash
+# Top-level packages
+find [apktool_dir]/smali -maxdepth 3 -type d | sed 's|.*/smali/||' | sort
+
+# Multi-dex check
+find [apktool_dir] -name "smali*" -maxdepth 1 -type d
+
+# Resource counts
+ls [apktool_dir]/res/layout/ 2>/dev/null | wc -l
+ls [apktool_dir]/res/drawable*/ 2>/dev/null | wc -l
+
+# Native + Assets
+find [apktool_dir]/lib -name "*.so" 2>/dev/null
+ls [apktool_dir]/assets/ 2>/dev/null
+```
+
+### 0.2: Phân loại thư viện
+
+Dùng patterns từ `library-patterns.md`, phân thành 5 nhóm:
+
+| Category | Example | Action |
+|----------|---------|--------|
+| ✅ Reuse | Retrofit, OkHttp | Add to build.gradle |
+| 🔄 Replace | Volley, AsyncTask | Map to modern |
+| 🔵 Google/Firebase | FCM, Analytics | Use latest |
+| 📱 Native | .so files | Keep, JNI bridge |
+| 🏷️ App Code | com.app.* | Rebuild |
+
+### 0.3: User approval
+
+> **GATE:** Hiển thị Library Report → User approve trước khi tiếp.
+
+---
+
+## 📄 Step 1: Manifest Analysis
+
+```bash
+cat [apktool_dir]/AndroidManifest.xml
+```
+
+### 1.1: Trích xuất
+
+- Application ID + Package name
+- Min/Target SDK
+- Permissions (phân nhóm: network, storage, camera, location, other)
+- Entry points: Application class, Launcher Activity, MainActivity
+- Components: Activities (→ future screens), Services, Receivers, Providers
+- Deep links / Intent filters
+
+### 1.2: Screen Map
+
+Map Activities → future Compose screens:
+
+```
+SplashActivity    → presentation/screens/splash/
+LoginActivity     → presentation/screens/auth/
+MainActivity      → presentation/screens/main/
+DetailActivity    → presentation/screens/detail/
+SettingsActivity  → presentation/screens/settings/
+```
+
+Draw navigation flow (ASCII or Mermaid).
+
+### 1.3: Complexity Estimate
+
+| Area | Rating | Notes |
+|------|--------|-------|
+| Data Layer | ●●●○○ | [evidence] |
+| Core Logic | ●●○○○ | [evidence] |
+| UI Screens | ●●●●○ | [evidence] |
+| SDK Integration | ●●○○○ | [evidence] |
+
+---
+
+## 📊 Output: App Map
+
+Sử dụng template từ `skills/smali-to-kotlin/templates/app-map.md`:
+
+```markdown
+## 🗺️ App Map: [App Name]
+
+### Identity
+[package, SDK, counts]
+
+### Screen Flow
+[navigation graph]
+
+### Library Landscape
+[categorized table]
+
+### Complexity Estimate
+[rating dots]
+
+### Key Observations
+[notable findings]
+```
+
+---
+
+## ✅ Gate: Chuyển sang Phase 1
+
+```
+"🗺️ App Map xong! Anh review map này.
+Có gì cần điều chỉnh không? OK → em sẽ thiết kế Architecture."
+
+→ User approves → /re-android-design (Phase 1)
+→ User has questions → investigate và update map
+```
+
+---
+
+## 🔗 Related
+
+- **Next:** [`/re-android-design`](reverse-android-design.md) (Phase 1: Architecture)
+- **Parent:** [`/reverse-android`](reverse-android.md)
+- **Skill reference:** `skills/smali-to-kotlin/phase-0-discovery.md`
+
+---
+
+*re-android-discover v3.0.0 — Phase 0: Discovery & App Map*