@leejungkiin/awkit 1.7.1 → 1.7.4

package/workflows/_uncategorized/pixel-setup.md

@@ -0,0 +1,90 @@
+---
+description: "🎮 Setup pixel-mcp MCP Server cho Aseprite pixel art"
+---
+
+# Pixel Setup — First-Time Configuration
+
+## Prerequisites Check
+
+1. **Verify Aseprite installation:**
+```bash
+# macOS
+ls -la /Applications/Aseprite.app/Contents/MacOS/aseprite 2>/dev/null && echo "✅ Aseprite found" || echo "❌ Aseprite not found"
+
+# Linux
+which aseprite 2>/dev/null && echo "✅ Aseprite found" || echo "❌ Aseprite not found"
+```
+
+2. **Detect Aseprite path:**
+- macOS: `/Applications/Aseprite.app/Contents/MacOS/aseprite`
+- Linux: `/usr/bin/aseprite` or `/usr/local/bin/aseprite`
+- Windows: `C:\Program Files\Aseprite\Aseprite.exe`
+
+If Aseprite not found, inform user:
+> ⚠️ Aseprite chưa được cài đặt. Tải từ https://www.aseprite.org/ (có phí) hoặc build từ source (miễn phí).
+
+## Step 1: Install pixel-mcp
+
+```bash
+# Option A: Download pre-built binary from GitHub Releases
+# https://github.com/willibrandon/pixel-mcp/releases
+
+# Option B: Build from source (requires Go 1.23+)
+git clone https://github.com/willibrandon/pixel-mcp.git /tmp/pixel-mcp-build
+cd /tmp/pixel-mcp-build
+make build
+mkdir -p ~/.local/bin
+cp bin/pixel-mcp ~/.local/bin/pixel-mcp
+chmod +x ~/.local/bin/pixel-mcp
+echo "✅ pixel-mcp installed to ~/.local/bin/pixel-mcp"
+```
+
+## Step 2: Create Configuration
+
+```bash
+mkdir -p ~/.config/pixel-mcp
+cat > ~/.config/pixel-mcp/config.json << 'PIXEL_CONFIG'
+{
+  "aseprite_path": "/Applications/Aseprite.app/Contents/MacOS/aseprite",
+  "temp_dir": "/tmp/pixel-mcp",
+  "timeout": 30,
+  "log_level": "info"
+}
+PIXEL_CONFIG
+echo "✅ Config created at ~/.config/pixel-mcp/config.json"
+```
+
+**Note:** If user provides Aseprite path as argument `$1`, use that instead of the default macOS path.
+
+## Step 3: Verify MCP Server
+
+```bash
+~/.local/bin/pixel-mcp --health 2>&1 || echo "⚠️ Health check failed — may need Aseprite path correction"
+```
+
+## Step 4: Add to MCP Config (if not already present)
+
+Check if `aseprite` entry exists in the user's MCP config. If not, add it:
+
+```json
+{
+  "aseprite": {
+    "command": "~/.local/bin/pixel-mcp",
+    "args": []
+  }
+}
+```
+
+## Done
+
+Report to user:
+```
+✅ Pixel MCP Setup Complete
+- Aseprite: [detected path]
+- pixel-mcp: ~/.local/bin/pixel-mcp
+- Config: ~/.config/pixel-mcp/config.json
+- Status: [health check result]
+
+Bạn có thể bắt đầu tạo pixel art bằng cách mô tả. Ví dụ:
+"Tạo một sprite Game Boy 32x32 của một nhân vật"
+```

package/workflows/_uncategorized/ponytail-review.md

@@ -0,0 +1,59 @@
+---
+description: Review code hoặc diff để phát hiện over-engineering. Chỉ ra code thừa, stdlib bị viết lại, dependency không cần thiết.
+alwaysApply: false
+priority: "medium"
+---
+
+# Ponytail Review — Over-Engineering Audit
+
+## 🎯 Mục đích
+
+Quét code/diff để tìm các điểm phức tạp không cần thiết. Không review logic/security — chỉ hunt complexity.
+
+## 🔧 Quy trình thực hiện
+
+### Bước 1: Xác định phạm vi
+- Nếu user chỉ định file/directory → quét đó.
+- Nếu không → quét diff hiện tại (`git diff --staged` hoặc `git diff`).
+- Nếu không có diff → quét toàn bộ `src/` hoặc thư mục code chính.
+
+### Bước 2: Áp dụng Ponytail Ladder ngược
+Với mỗi đoạn code, kiểm tra:
+1. **Có cần tồn tại không?** → Tag `delete:` nếu speculative/dead.
+2. **Stdlib đã có?** → Tag `stdlib:` + tên hàm stdlib thay thế.
+3. **Native platform có?** → Tag `native:` + tên feature thay thế.
+4. **Abstraction duy nhất?** → Tag `yagni:` nếu interface/factory/wrapper chỉ có 1 implementation.
+5. **Có thể ngắn hơn?** → Tag `shrink:` + đoạn code rút gọn.
+
+### Bước 3: Output format
+```
+L<line>: <tag> <what>. <replacement>.
+```
+Hoặc multi-file:
+```
+<file>:L<line>: <tag> <what>. <replacement>.
+```
+
+### Bước 4: Tổng kết
+```
+net: -<N> lines possible.
+```
+Nếu code đã tối giản: `Lean already. Ship.`
+
+## 📋 Ví dụ Output
+
+```
+L12-38: stdlib: 27-line email validator. "@" in email, 1 line.
+L4: native: moment.js for one format call. Intl.DateTimeFormat, 0 deps.
+utils.py:L88: yagni: AbstractRepository, 1 impl. Inline it.
+L52-71: delete: retry wrapper on idempotent local call. Nothing.
+L30-44: shrink: manual loop → dict(zip(keys, values)), 1 line.
+
+net: -87 lines possible.
+```
+
+## ⚠️ Ranh giới
+
+- KHÔNG flag smoke tests hoặc assert-based self-checks — đó là ponytail minimum.
+- KHÔNG sửa code — chỉ liệt kê findings.
+- Correctness bugs, security holes → dùng review workflow khác.

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

@@ -0,0 +1,222 @@
+---
+description: 🔨 RE Android Phase 2+3+4 — Blueprint + UI Shell → Logic Build → Final Parity (UI-First)
+parent: reverse-android
+---
+
+# /re-android-build — Blueprint + UI + Build (Per Feature)
+
+> **Parent:** [`/reverse-android`](reverse-android.md) → Phase 2+3+4
+> **Prerequisite:** Completed Architecture from [`/re-android-design`](reverse-android-design.md)
+> **Skill:** `smali-to-kotlin` → `phase-2-blueprint-ui.md` + `phase-3-logic-build.md`
+
+---
+
+## 🔄 Feature Loop (UI-First)
+
+```
+For each feature (from Architecture Build Order):
+    Phase 2: Blueprint + UI (contracts + visual shell)
+        ↓ 🚦 GATE: User approves UI + contracts
+    Phase 3: Logic Build (domain → data → wire)
+        ↓ 📊 CHECKPOINT
+    → Next feature
+```
+
+---
+
+## 📐🎨 Phase 2: Blueprint + UI Design
+
+> **Output:** Approved contracts + Working Compose UI shell with mock data.
+
+### Part A: Contracts (signatures only)
+
+#### 2.1: Deep Smali Reading
+Read Smali files for the chosen feature. Extract class hierarchy, fields, method signatures,
+string constants, control flow. See `smali-reading-guide.md`.
+
+#### 2.2–2.5: Define Contracts
+```kotlin
+// 2.2 Domain Model
+data class [Model](val field: Type, ...)
+
+// 2.3 Repository Interface
+interface [Feature]Repository {
+    suspend fun [method](...): Result<[Type]>
+}
+
+// 2.4 API Interface
+interface [Feature]Api {
+    @[METHOD]("[endpoint]")
+    suspend fun [method](...): [Response]
+}
+
+// 2.5 UseCase
+class [Action]UseCase(repo: [Feature]Repository) {
+    suspend operator fun invoke(...): Result<[Type]> // TODO()
+}
+```
+
+#### 2.6: UI State Design
+```kotlin
+data class [Screen]UiState(
+    val field: Type = default,
+    val isLoading: Boolean = false,
+    val error: String? = null
+)
+sealed interface [Screen]Event { /* navigation, snackbar */ }
+sealed interface [Screen]Action { /* user interactions */ }
+```
+
+### Part B: UI Visual Shell
+
+#### 2.7: Resource Extraction ⭐ (BEFORE UI code!)
+
+```bash
+# Only resources for THIS screen
+grep -o '@drawable/[a-z_]*' [apktool_dir]/res/layout/activity_[screen].xml | sort -u
+grep -o '@color/[a-z_]*' [apktool_dir]/res/layout/activity_[screen].xml | sort -u
+```
+
+Copy ONLY needed resources. Verify they compile.
+
+#### 2.8: UI Implementation ⭐ (Visual shell with mock data)
+
+- Use UiState from 2.6 with hardcoded defaults
+- Use REAL resources from 2.7
+- Create `[Screen]Content` composable (stateless)
+- Match visual parity with original app
+- NO ViewModel connection, NO real API calls
+
+```kotlin
+@Composable
+fun [Screen]Content(
+    uiState: [Screen]UiState = [Screen]UiState(),  // Mock
+    onAction: ([Screen]Action) -> Unit = {}          // No-op
+) {
+    // Full Compose UI matching original app
+}
+
+@Preview @Composable
+private fun NormalPreview() { AppTheme { [Screen]Content() } }
+
+@Preview @Composable
+private fun LoadingPreview() { AppTheme { [Screen]Content([Screen]UiState(isLoading = true)) } }
+
+@Preview @Composable
+private fun ErrorPreview() { AppTheme { [Screen]Content([Screen]UiState(error = "Error")) } }
+```
+
+#### 2.9: Visual Parity Check ⭐
+
+Compare with original app:
+- [ ] Layout structure matches
+- [ ] Colors, typography, spacing correct
+- [ ] Icons/images positioned correctly
+- [ ] All states: normal, loading, error, empty
+
+### 🚦 UI + Contracts Gate (MANDATORY)
+
+```
+"📐🎨 Blueprint + UI cho [Feature] xong:
+📝 Contracts: [N] models, [N] repos, [N] use cases, [N] APIs
+🎨 UI: [Screen] with [N] state previews
+📸 Visual Parity: [OK / needs adjustment]
+
+→ ✅ Approve → Phase 3 (Logic Build)
+→ 🎨 Adjust UI → fix then re-check
+→ 📝 Adjust contracts → revise"
+```
+
+> ⚠️ **DO NOT proceed to Phase 3 without user approval.**
+
+---
+
+## 🔨 Phase 3: Logic Build
+
+> **Output:** Full production-quality Kotlin code. Wire logic to EXISTING UI.
+
+### 3.1: Domain Layer
+Models + Repository interfaces + UseCases (implement invoke with repo calls)
+
+### 3.2: Data Layer
+DTOs + Retrofit API + Room (if applicable) + Repository implementation
+
+### 3.3: DI Module
+Hilt @Module with @Binds for repository
+
+### 3.4: ViewModel
+@HiltViewModel with StateFlow + SharedFlow, implements onAction()
+
+### 3.5: Wire UI ↔ Logic ⭐ (NOT "code new UI")
+
+The UI already exists from Phase 2.8. Only CONNECT it:
+
+```kotlin
+// Keep stateless Content composable from Phase 2 (for Preview):
+// [Screen]Content(uiState, onAction) — DO NOT MODIFY
+
+// ADD wrapper that wires ViewModel:
+@Composable
+fun [Screen](
+    viewModel: [Screen]ViewModel = hiltViewModel(),
+    onNavigate: () -> Unit
+) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    LaunchedEffect(Unit) {
+        viewModel.events.collect { event -> /* handle navigation */ }
+    }
+    [Screen]Content(uiState = uiState, onAction = viewModel::onAction)
+}
+```
+
+### 3.6: Integration Test ⭐
+- [ ] API calls succeed, data displays
+- [ ] Loading/error states work
+- [ ] Navigation correct
+- [ ] Crypto output matches (if applicable)
+
+### 🔒 Crypto Utils (Special)
+If crypto involved: implement + unit test IMMEDIATELY with known pairs.
+> ⚠️ MUST produce identical output.
+
+### ✅ Feature Checkpoint
+
+```markdown
+## ✅ Feature Complete: [Name]
+Files: [list] | Resources: [count] | Tests: [status]
+⏭️ Next Feature: [Name] → Return to Phase 2
+```
+
+---
+
+## ✅ Phase 4: Final Parity Check (After ALL features)
+
+### 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: `./gradlew assembleDebug && ./gradlew test && ./gradlew lint`
+
+### 🎉 Final Summary
+
+```markdown
+## ✅ Reverse Engineering Complete!
+- Screens: [N] | Features: [N]
+- Libs reused: [N] | Replaced: [N]
+- Tests: [pass/fail] | Lint: [warnings]
+
+⏭️ Next: /test → /deploy → /code-janitor
+```
+
+---
+
+## 🔗 Related
+
+- **Parent:** [`/reverse-android`](reverse-android.md)
+- **Previous:** [`/re-android-design`](reverse-android-design.md) (Phase 1)
+- **Skill:** `smali-to-kotlin` → `phase-2-blueprint-ui.md` + `phase-3-logic-build.md`
+
+---
+
+*re-android-build v4.0.0 — UI-First Blueprint + Build*

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

@@ -0,0 +1,139 @@
+---
+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 (UI-First) ⭐
+
+| # | Phase | Scope | Complexity |
+|---|-------|-------|-----------|
+| 1 | 🟢 Foundation | Project + DI skeleton + Theme/Design System | Low |
+| 2 | 🟢 Navigation | Routes, tab bar, NavGraph | Low |
+| 3 | 🔵 Per Feature | Blueprint (contracts) + UI Shell (visual) | Medium |
+| 4 | 🚦 UI Gate | User approves UI before logic | — |
+| 5 | 🟡 Per Feature | Logic Build (Domain → Data → VM → Wire UI) | High |
+| 6 | 📦 SDKs | Third-party SDK + Native libs integration | Medium |
+| N | 🔴 Final | Full Parity Check | High |
+
+> **UI-First:** Design and approve UI before coding logic for each feature.
+
+## 🔧 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/_uncategorized/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*