@leejungkiin/awkit 1.0.0

package/workflows/quality/bug-hunter.md

@@ -0,0 +1,243 @@
+---
+description: 🐛 Tìm, tái hiện & sửa lỗi từ log
+safe_auto_run: false
+---
+
+# /bug-hunter - The Bug Detective
+
+A forensic approach to fixing bugs with progressive solutions.
+
+---
+
+## Phase 1: Triage & Reproduction
+
+### 1.1. Bug Classification
+"What type of bug is this?"
+- A) **Crash** - App terminates unexpectedly
+- B) **UI Glitch** - Visual issues
+- C) **Logic Error** - Wrong behavior/output
+- D) **Performance** - Slow/laggy
+- E) **Intermittent** - Happens sometimes (hardest!)
+
+### 1.2. Gather Evidence
+```markdown
+**Bug Report:**
+- Description: [What's happening]
+- Expected: [What should happen]
+- Steps to reproduce: [1, 2, 3...]
+- Frequency: [Always/Sometimes/Rare]
+- Environment: [Device, OS, App version]
+- Logs/Screenshots: [Attached]
+```
+
+### 1.3. Create Reproduction Test
+// turbo
+```swift
+// iOS - Create failing test first (TDD approach)
+func testBugReproduction_ISSUE123() {
+    // Arrange - Set up the conditions
+    let sut = SystemUnderTest()
+    
+    // Act - Perform the action that triggers bug
+    let result = sut.performAction()
+    
+    // Assert - This should FAIL initially
+    XCTAssertEqual(result, expectedValue)
+}
+```
+
+```kotlin
+// Android
+@Test
+fun `ISSUE-123 - bug reproduction`() {
+    // Arrange
+    val sut = SystemUnderTest()
+    
+    // Act
+    val result = sut.performAction()
+    
+    // Assert - Should FAIL initially
+    assertEquals(expectedValue, result)
+}
+```
+
+---
+
+## Phase 2: Three-Level Root Cause Analysis
+
+### Level 1: WHAT (Surface)
+> What is the observable symptom?
+
+### Level 2: WHY (Root Cause)
+> What is the underlying technical cause?
+
+### Level 3: HOW (Solution)
+> What is the specific fix?
+
+**Example:**
+```markdown
+**Level 1 (Surface):** User sees stale data after pulling to refresh
+
+**Level 2 (Root Cause):** 
+- API response is cached
+- Cache invalidation not triggered on pull-to-refresh
+- StateFlow not updated with fresh data
+
+**Level 3 (Solution):**
+```kotlin
+fun refresh() {
+    viewModelScope.launch {
+        // Force cache bypass
+        repository.fetchData(forceRefresh = true)
+    }
+}
+```
+```
+
+---
+
+## Phase 3: Progressive Solutions
+
+### 1️⃣ Minimal Fix (Quick Patch)
+- Fix the immediate symptom
+- May not address root cause
+- Acceptable for urgent hotfixes
+
+```swift
+// Quick fix: Force unwrap guard
+if data == nil { return } // Band-aid
+```
+
+### 2️⃣ Better Fix (Proper Solution)
+- Address the root cause
+- Add defensive checks
+- Includes basic test
+
+```swift
+// Proper fix: Handle nil case correctly
+guard let data = data else {
+    showError("No data available")
+    return
+}
+```
+
+### 3️⃣ Complete Fix (Robust Solution)
+- Fix + refactor if needed
+- Comprehensive tests
+- Documentation update
+- Monitoring added
+
+```swift
+// Robust: Full error handling + logging
+do {
+    let data = try await fetchData()
+    await MainActor.run { updateUI(with: data) }
+} catch {
+    Logger.error("Data fetch failed: \(error)")
+    showUserFriendlyError(error)
+    Analytics.track("data_fetch_error", error: error)
+}
+```
+
+---
+
+## Phase 4: Isolation Techniques
+
+### 4.1. Binary Search (Bisect)
+```bash
+# Find the commit that introduced the bug
+git bisect start
+git bisect bad HEAD
+git bisect good v1.0.0
+# Git will help find the exact commit
+```
+
+### 4.2. Strategic Logging
+```swift
+// Add temporary debug logs
+func suspectFunction() {
+    print("🔍 DEBUG: Entering suspectFunction")
+    print("🔍 DEBUG: Variable state = \(variable)")
+    // ... logic
+    print("🔍 DEBUG: Exiting with result = \(result)")
+}
+```
+
+### 4.3. Divide and Conquer
+1. Comment out half the suspect code
+2. Does bug still occur?
+3. If yes → bug in remaining code
+4. If no → bug in commented code
+5. Repeat until isolated
+
+---
+
+## Phase 5: Fix Implementation
+
+### 5.1. Apply Fix
+Based on severity, apply appropriate level fix (Minimal/Better/Complete)
+
+### 5.2. Verify with Reproduction Test
+// turbo
+```bash
+# iOS
+xcodebuild test -only-testing:TestTarget/testBugReproduction_ISSUE123
+
+# Android
+./gradlew testDebugUnitTest --tests "*ISSUE123*"
+```
+
+### 5.3. Regression Check
+// turbo
+```bash
+# Run related tests to ensure nothing else broke
+# iOS
+xcodebuild test -workspace *.xcworkspace -scheme [Scheme]
+
+# Android
+./gradlew testDebugUnitTest
+```
+
+---
+
+## Phase 6: Cleanup & Documentation
+
+### 6.1. Remove Debug Code
+```bash
+# Find and remove debug logs
+grep -rn "DEBUG\|🔍" --include="*.swift" --include="*.kt"
+```
+
+### 6.2. Update Documentation
+- Add to known issues if relevant
+- Update CHANGELOG
+- Link to issue tracker
+
+### 6.3. Report
+```markdown
+## 🐛 Bug Fix Report
+
+**Issue:** [ID or Description]
+**Root Cause:** [What was actually wrong]
+**Solution Level:** Minimal/Better/Complete
+**Fix Applied:** [Description of changes]
+
+**Files Changed:**
+- `FileName.swift` - [What changed]
+
+**Verification:**
+- ✅ Reproduction test passes
+- ✅ Regression tests pass
+- ✅ Manual verification done
+
+**Prevention:**
+- [What can prevent similar bugs]
+```
+
+---
+
+## ⚠️ NEXT STEPS:
+- Bug fixed → `/test` to run full suite
+- Need deeper analysis → `/oracle`
+- Made it worse → `/rollback`
+- All good → `/smart-git-ops` to commit

package/workflows/quality/code-janitor.md

@@ -0,0 +1,209 @@
+---
+description: 🧹 Bảo trì mã nguồn & dọn tài nguyên thừa
+safe_auto_run: true
+---
+
+# /code-janitor - Mobile Project Cleaner
+
+Keeps iOS/Android/Expo projects clean and consistent.
+
+---
+
+## Phase 1: Localization Audit
+// turbo
+
+### iOS (Swift)
+1. **Scan for hardcoded strings:**
+   ```swift
+   // BAD
+   Text("Welcome back!")
+   
+   // GOOD
+   Text(LocalizedStringKey("welcome_back"))
+   ```
+
+2. **Find missing keys:**
+   - Scan all `.swift` files for `LocalizedStringKey` usage
+   - Compare with `Localizable.strings`
+   - Report missing translations
+
+3. **Auto-fix:**
+   - Extract hardcoded strings to `Localizable.strings`
+   - Replace with localization keys
+
+### Android (Kotlin)
+1. **Scan for hardcoded strings:**
+   ```kotlin
+   // BAD
+   Text("Welcome back!")
+   
+   // GOOD
+   stringResource(R.string.welcome_back)
+   ```
+
+2. **Find missing keys:**
+   - Scan for string usage
+   - Compare with `strings.xml`
+
+### Expo (TypeScript)
+1. **Scan for hardcoded strings:**
+   - Check for strings in components
+   - Verify i18n usage if configured
+
+---
+
+## Phase 2: Unused Resource Cleanup
+// turbo
+
+### iOS
+1. **Unused Images:**
+   ```bash
+   # Find images in Assets.xcassets not referenced in code
+   find . -name "*.swift" -exec grep -l "imageName" {} \;
+   ```
+   
+2. **Unused Colors:**
+   - Check Color assets vs code usage
+
+3. **Dead Code:**
+   - Run SwiftLint for unused imports
+   - Find unreferenced classes/structs
+
+### Android
+1. **Unused Resources:**
+   ```bash
+   ./gradlew lintDebug
+   # Check "UnusedResources" warnings
+   ```
+
+2. **Unused Dependencies:**
+   - Check for unused Gradle dependencies
+
+### Expo
+1. **Unused packages:**
+   ```bash
+   npx depcheck
+   ```
+
+2. **Unused images:**
+   - Scan `assets/` folder vs imports
+
+---
+
+## Phase 3: Code Formatting
+// turbo
+
+### iOS
+```bash
+# SwiftFormat
+swiftformat . --config .swiftformat
+
+# SwiftLint auto-correct
+swiftlint --fix
+```
+
+### Android
+```bash
+# Ktlint
+./gradlew ktlintFormat
+
+# Or standalone
+ktlint -F "**/*.kt"
+```
+
+### Expo
+```bash
+# Prettier + ESLint
+npm run lint -- --fix
+npx prettier --write "**/*.{ts,tsx}"
+```
+
+---
+
+## Phase 4: Project-Specific Cleanup
+
+### iOS
+// turbo
+1. **Info.plist validation:**
+   - Check required keys present
+   - Verify bundle identifiers
+
+2. **Build Settings:**
+   - Check for deprecated settings
+   - Verify signing configuration
+
+3. **Podfile cleanup:**
+   - Remove unused pods
+   - Update pod versions
+
+### Android
+// turbo
+1. **Manifest validation:**
+   - Check permissions
+   - Verify activities/services
+
+2. **Gradle cleanup:**
+   - Remove deprecated dependencies
+   - Update dependency versions
+
+3. **ProGuard rules:**
+   - Verify rules are current
+
+### Expo
+// turbo
+1. **app.json validation:**
+   - Check required fields
+   - Verify splash/icon paths
+
+2. **Package.json cleanup:**
+   - Remove unused dependencies
+   - Update versions
+
+---
+
+## Phase 5: File Organization Check
+
+### Verify Architecture Compliance
+1. **Check if files are in correct folders:**
+   - Views in Views/
+   - ViewModels in ViewModels/
+   - Models in Models/
+
+2. **Check naming conventions:**
+   - iOS: PascalCase for files
+   - Android: PascalCase for Kotlin, lowercase for resources
+   - Expo: PascalCase for components
+
+---
+
+## Phase 6: Report
+// turbo
+
+```markdown
+# 🧹 Code Janitor Report
+
+## Localization
+- Hardcoded strings found: X
+- Strings extracted: Y
+- Missing translations: Z
+
+## Resources
+- Unused images removed: X
+- Unused code detected: Y files
+
+## Formatting
+- Files formatted: X
+- Lint issues fixed: Y
+
+## Recommendations
+- [ ] Review unused code before deletion
+- [ ] Update translations for new strings
+- [ ] Run /test after cleanup
+```
+
+---
+
+## ⚠️ NEXT STEPS:
+- Review changes → Commit with `/smart-git-ops`
+- Verify nothing broke → `/run`
+- Full audit → `/ux-audit`

package/workflows/quality/code-quality-rules.md

@@ -0,0 +1,132 @@
+---
+description: Kiểm tra chất lượng code, tiêu chuẩn SOLID và các mẫu sửa lỗi tự động.
+alwaysApply: false
+priority: "high"
+---
+
+# Code Quality & AI Automation Rules
+
+## 🎯 Core Purpose
+
+**_BẮT BUỘC_** manual workflow cho AI assistants để tự động thực hiện code quality checks mà không dựa vào IDE auto-tools.
+
+## 🔧 MANDATORY AI Execution Rules
+
+### Before Writing Any Code
+
+**_BẮT BUỘC_** AI phải thực hiện checklist này trước khi viết bất kỳ dòng code nào:
+
+```markdown
+☐ 1. SCAN existing file structure và imports
+☐ 2. IDENTIFY required dependencies và packages  
+☐ 3. PREDICT potential import conflicts
+☐ 4. VALIDATE target file syntax structure
+☐ 5. PREPARE import statements list
+☐ 6. CHECK for existing naming conventions
+☐ 7. VERIFY package declarations match directory
+```
+
+### During Code Writing
+
+**_BẮT BUỘC_** AI phải thực hiện real-time validation:
+
+```markdown
+☐ 1. ADD import statements ngay khi sử dụng class mới
+☐ 2. VALIDATE type compatibility trước khi assignment
+☐ 3. CHECK null safety cho tất cả nullable operations
+☐ 4. ENSURE proper bracket matching trong real-time
+☐ 5. VALIDATE function signatures match usage
+☐ 6. CHECK variable naming conventions
+☐ 7. VERIFY proper indentation và formatting
+```
+
+### After Code Completion
+
+**_BẮT BUỘC_** AI phải thực hiện final validation:
+
+```markdown
+☐ 1. SCAN for any missing imports
+☐ 2. OPTIMIZE import statements (remove unused)
+☐ 3. FINAL type safety validation
+☐ 4. COMPLETE syntax error check
+☐ 5. VALIDATE code style consistency
+☐ 6. CHECK for potential performance issues
+☐ 7. ENSURE proper error handling patterns
+```
+
+## Code Quality Standards
+
+### Code Style
+- **Naming**: Use consistent, meaningful English naming (camelCase for vars, PascalCase for classes, UPPER_CASE for constants).
+- **Comments**: Explain "Why", not "What".
+- **Formatting**: Consistent indentation (spaces vs tabs) and spacing.
+
+### Architecture & Design
+- **SOLID**: Follow SOLID principles strictly.
+- **Layers**: Clear separation of concerns (Presentation, Business, Data).
+- **Dependency Injection**: Use DI to decouple components.
+- **Composition over Inheritance**: Prefer composition.
+
+### Error Handling
+- **Exceptions**: Catch specific exceptions, not generic ones.
+- **Messages**: Provide meaningful, safe error messages.
+- **Logging**: Log errors with context.
+
+### Performance
+- **Database**: Avoid N+1 queries.
+- **Caching**: Implement caching where appropriate.
+- **Async**: Use async/await for non-blocking operations.
+
+### Security
+- **Input Validation**: Validate all inputs.
+- **Sanitization**: Sanitize data before display to prevent XSS.
+- **SQL Injection**: Use parameterized queries.
+- **Secrets**: Never hardcode secrets.
+
+## 🔍 Manual Code Quality Checklist
+
+### Critical Issues (Must Fix Immediately)
+
+```markdown
+Priority: CRITICAL - Block execution until fixed
+
+☐ Missing import statements → AUTO-ADD appropriate imports
+☐ Syntax errors (brackets, semicolons) → AUTO-FIX basic syntax
+☐ Type mismatches → AUTO-CONVERT with safety checks
+☐ Null pointer risks → AUTO-ADD safe call operators
+☐ Unresolved references → AUTO-RESOLVE or flag for manual review
+```
+
+### High Priority Issues (Fix Before Proceeding)
+
+```markdown
+Priority: HIGH - Fix immediately after critical issues
+
+☐ Unused imports → AUTO-REMOVE unused imports
+☐ Incorrect naming conventions → SUGGEST corrections
+☐ Missing error handling → AUTO-ADD basic try-catch
+☐ Performance anti-patterns → FLAG for review
+☐ Security vulnerabilities → FLAG for immediate review
+```
+
+## 🛠️ Common Fix Templates
+
+### Android/Kotlin Examples
+
+```kotlin
+// AUTO-FIX TEMPLATE: Null safety
+// BEFORE: user.name
+// AFTER: user?.name
+
+// AUTO-FIX TEMPLATE: Missing brackets
+// BEFORE: if (condition) doSomething()
+// AFTER: if (condition) { doSomething() }
+```
+
+### General Syntax Fixes
+
+```javascript
+// AUTO-FIX TEMPLATE: Missing generic error handling
+// BEFORE: try { call() } catch (e) { log(e) }
+// AFTER: try { call() } catch (e) { logger.error("Call failed", e); throw new ServiceException(e) }
+```