@leejungkiin/awkit 1.0.0

package/workflows/context/auto-implement.md

@@ -0,0 +1,211 @@
+---
+description: 🤖 Tự động thực thi code từ Spec
+---
+
+# /auto-implement - Spec Executor
+
+> **Role:** Antigravity Builder - Đọc specs, code tự động.
+> **Input:** `docs/specs/[feature]/` (đã tạo bởi /design-feature)
+> **Output:** Production-ready code
+
+---
+
+## Phase 0: Load Specs
+
+### 0.1. Verify Specs Exist
+// turbo
+```bash
+FEATURE=$1  # Pass feature name as argument
+[ -d "docs/specs/$FEATURE" ] && echo "✅ Specs found" || echo "❌ No specs"
+```
+
+### 0.2. Load All Spec Files
+Đọc và parse:
+1. `requirements.md` → Hiểu WHAT & WHY
+2. `design.md` → Hiểu HOW (architecture, models, UI)
+3. `bd list` → Hiểu execution plan (list tasks in JSON format for parsing)
+
+### 0.3. Parse Tasks
+Retrieve tasks using `bd list --json`:
+- Extract task ID
+- Extract description and body
+- Extract requirements from body tags
+
+---
+
+## Phase 1: Execution Loop
+
+### 1.1. For Each Uncompleted Task
+
+```
+FOR each task WHERE status = "[ ]":
+  1. READ task description
+  2. READ related design.md section
+  3. READ related requirements
+  4. GENERATE code
+  5. WRITE to specified file
+  6. VERIFY (syntax check)
+  7. MARK task as complete: `bd close [id]`
+  8. REPORT progress
+END FOR
+```
+
+### 1.2. Execution Rules
+
+**Sequential:** Thực hiện theo thứ tự A → B → C → D → E
+
+**Context Awareness:**
+- Đọc existing code trước khi modify
+- Không duplicate logic đã có
+- Reuse existing components/utils
+
+**Quality Gates:**
+- Mỗi task phải pass syntax check
+- Nếu fail → stop và report, không continue
+
+---
+
+## Phase 2: Code Generation
+
+### 2.1. Per Task Type
+
+**type: logic** (Models, ViewModels, Services)
+```swift
+// Auto-generate based on design.md Data Models section
+// Include: Codable, Identifiable, validation
+// Follow: Clean Architecture patterns
+```
+
+**type: ui** (Views, Components)
+```swift
+// Auto-generate based on Component Hierarchy
+// Apply: Design tokens from design.md
+// Include: Accessibility labels, animations
+```
+
+**type: i18n** (Localization)
+```swift
+// Scan all created files
+// Extract hardcoded strings
+// Replace with Localized("key")
+```
+
+**type: test** (Unit Tests)
+```swift
+// Generate tests for ViewModels, Repositories
+// Cover: Happy path, error cases
+// Target: 80%+ coverage
+```
+
+### 2.2. Code Standards
+
+Mọi code phải tuân thủ:
+- [ ] No hardcoded strings (use localization)
+- [ ] Error handling với do-catch
+- [ ] Logging quan trọng actions
+- [ ] Input validation
+- [ ] Accessibility labels
+
+---
+
+## Phase 3: Progress Tracking
+
+### 3.1. Update Status
+Sau mỗi task hoàn thành:
+```bash
+bd close [id]
+```
+
+### 3.2. Progress Report
+```
+📊 Implementation Progress: [feature]
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Phase A: ██████████ 100% (2/2 tasks)
+Phase B: ██████░░░░  60% (3/5 tasks)
+Phase C: ░░░░░░░░░░   0% (0/2 tasks)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Overall: 45% complete
+
+✅ Completed: A1, A2, B1, B2, B3
+🔄 Current: B4 - Create Item Detail
+⏳ Pending: B5, C1, C2, D1, D2, E1, E2
+```
+
+---
+
+## Phase 4: Completion
+
+### 4.1. Final Checklist
+Khi tất cả tasks `[x]`:
+- [ ] All requirements validated
+- [ ] Build passes without errors
+- [ ] No hardcoded strings
+- [ ] Accessibility implemented
+- [ ] Tests written and passing
+
+### 4.2. Handover
+```
+✅ Feature [name] Implementation Complete!
+
+📁 Files Created/Modified:
+- Domain/Models/[Feature].swift
+- Data/Repositories/[Feature]Repository.swift
+- Presentation/[Feature]/[Feature]View.swift
+- Presentation/[Feature]/[Feature]ViewModel.swift
+
+📋 Requirements Validated:
+- RQ-01 ✅
+- RQ-02 ✅
+
+🧪 Tests: 5 passed, 0 failed
+
+Next Steps:
+- /run to test on device
+- /code-review before merge
+```
+
+---
+
+## Error Handling
+
+### Task Fails
+```
+❌ Task B2 Failed: [error message]
+
+Context:
+- File: Presentation/[Feature]/Components/ItemCard.swift
+- Line: 45
+- Error: Type 'ItemModel' has no member 'subtitle'
+
+Suggested Fix:
+- Check design.md for correct property names
+- Update ItemModel or fix reference
+
+Options:
+1. [Fix and retry] - Auto-attempt fix
+2. [Skip] - Continue to next task
+3. [Stop] - Pause for manual intervention
+```
+
+### Recovery
+- Tự động thử sửa lỗi đơn giản (missing import, typo)
+- Nếu không sửa được → Stop và báo cáo chi tiết
+
+---
+
+## Usage
+
+```bash
+# Execute all pending tasks
+/auto-implement user-profile
+
+# Execute specific phase only
+/auto-implement user-profile --phase=B
+
+# Dry run (show what would be done)
+/auto-implement user-profile --dry-run
+```
+
+---
+
+**Success:** Code hoàn chỉnh, validated, ready for testing.

package/workflows/context/codebase-sync.md

@@ -0,0 +1,163 @@
+---
+description: Đồng bộ CODEBASE.md với codebase thực tế — cập nhật delta, không rewrite toàn bộ
+---
+
+# /codebase-sync Workflow
+
+> **Mục đích:** Giữ CODEBASE.md luôn up-to-date với codebase thực tế.
+> **Nguyên tắc:** Chỉ append/update delta — không xóa thông tin cũ.
+> **Trigger:** Gate 2 (file mới tạo), user gõ /codebase-sync, hoặc AI thấy outdated.
+
+---
+
+## Triggers (Khi nào chạy)
+
+```
+AUTO triggers:
+  - Gate 2 hoàn thành + needs_codebase_sync = true trong session.json
+  - AI biết file không có trong CODEBASE.md (từ orchestrator W6 flag)
+
+MANUAL trigger:
+  - User gõ: /codebase-sync
+```
+
+---
+
+## Phase 1: Assess Current State
+
+```bash
+# 1. Đọc CODEBASE.md hiện tại
+cat CODEBASE.md
+
+# 2. Check git: files changed/added gần đây (14 ngày)
+git log --since="14 days ago" --name-only --pretty=format: | sort -u | grep -v '^$'
+
+# 3. Lấy session file edits từ memory-sync W6
+cat brain/session.json | grep files_touched_this_session
+
+# 4. Check new files không có trong CODEBASE.md
+# AI tự compare danh sách git + session với entries trong CODEBASE.md
+```
+
+**Output:**
+```
+📊 CODEBASE Sync Assessment:
+  - Files in CODEBASE.md: [N files documented]
+  - New/changed files (14d): [M files]
+  - Missing from CODEBASE.md: [K files listed]
+  - Last updated: [date from CODEBASE.md]
+```
+
+---
+
+## Phase 2: Generate Delta
+
+Với mỗi file thiếu trong CODEBASE.md, AI tự suy luận:
+
+```yaml
+for each missing_file:
+  1. Xác định layer:
+     - App/ → App Layer
+     - Core/Domain/ → Domain Layer
+     - Core/Data/ → Data Layer
+     - Core/Services/ → Services Layer
+     - Features/[X]/ → Features Layer
+     - Presentation/Views/ → Views
+     - Presentation/ViewModels/ → ViewModels
+
+  2. Xác định responsibility từ:
+     - Filename (AuthenticationViewModel → Auth UI logic)
+     - Directory (Core/Domain/UseCases → Business logic)
+     - Content (nếu cần, đọc file — chỉ khi không đủ context)
+
+  3. Generate entry:
+     - File: path/to/File.swift
+     - Layer: [layer name]
+     - Purpose: [1-line description]
+     - Key exports: [main class/struct/func]
+
+  4. Xác định section trong CODEBASE.md phù hợp để append
+```
+
+---
+
+## Phase 3: Update CODEBASE.md
+
+```yaml
+MO:
+  - APPEND vào đúng section, không xóa gì cũ
+  - Update "Last Updated" timestamp
+  - Nếu thêm feature mới → thêm section mới
+
+Format mỗi entry thêm vào:
+  #### [FileName.swift]
+  **Layer:** [Layer name]
+  **Purpose:** [Description]
+  **Key class/struct:** `ClassName`
+
+Footer update:
+  **Last Updated**: [current date]
+  **Sync:** Auto-updated via /codebase-sync
+```
+
+**Preview trước khi apply:**
+```
+📝 Sẽ thêm [K] entries vào CODEBASE.md:
+  + Core/Services/PushNotificationService.swift → Services Layer
+  + Features/WeeklyGoal/ViewModels/WeeklyGoalViewModel.swift → Features
+  + Presentation/Views/Dashboard/CombinedDashboardHeader.swift → Views
+
+Apply? [auto-yes nếu < 10 entries / confirm nếu lớn hơn]
+```
+
+---
+
+## Phase 4: Update Session State
+
+```json
+// brain/session.json — reset sau khi sync
+{
+  "codebase_last_synced": "2026-02-24T08:35:00Z",
+  "files_touched_this_session": [],
+  "needs_codebase_sync": false
+}
+```
+
+---
+
+## Output Summary
+
+```
+✅ CODEBASE.md Synced!
+
+  📊 Added: [K] new entries
+  📁 Sections updated: [list]
+  🕐 Last Updated: 2026-02-24
+
+💡 Next: AI sẽ dùng CODEBASE.md mới trong session tiếp theo
+   → Không cần scan cấu trúc thủ công nữa
+```
+
+---
+
+## Error Handling
+
+```yaml
+No CODEBASE.md found:
+  → AI tạo mới từ đầu bằng cách scan project structure
+  → Template dựa theo architecture trong .project-identity
+
+No .git found:
+  → Fallback: dùng session.json files_touched_this_session
+  → Scan core directories thủ công (App/, Core/, Features/, Presentation/)
+
+CODEBASE.md quá outdated (> 30 ngày):
+  → Warn: "CODEBASE.md rất cũ, nên rebuild toàn bộ?"
+  → Option A: Rebuild full (scan toàn bộ)
+  → Option B: Chỉ update delta 14 ngày gần nhất
+```
+
+---
+
+*codebase-sync v1.0 — Delta-based CODEBASE.md Synchronizer*
+*Created by Kien AI*

package/workflows/context/logic-reasoning-workflow.md

@@ -0,0 +1,260 @@
+---
+description: Quy trình suy luận logic để phân tích đặc trưng, đề xuất thông minh và phát hiện đặc trưng liên quan.
+alwaysApply: false
+category: workflow
+priority: medium
+triggers:
+  - "keywords: feature analysis, suggestions, recommendations"
+  - "context: product planning, feature ideation"
+  - "file_patterns: requirements.md, features.md"
+version: 1.0.0
+track:
+  - quick
+  - method
+  - enterprise
+---
+
+# Logic Reasoning Workflow
+
+## Core Logic Analysis
+
+### Feature Analysis Framework
+
+**Primary Analysis**:
+- **Feature Identification**: Extract all visible and implied features
+- **Feature Relationships**: Map dependencies and connections
+- **Feature Gaps**: Identify missing functionality
+- **Feature Redundancy**: Detect overlapping capabilities
+
+**Secondary Analysis**:
+- **User Journey Mapping**: Trace user paths through features
+- **Business Logic Extraction**: Identify business rules and constraints
+- **Technical Requirements**: Determine implementation needs
+- **Integration Points**: Find external system connections
+
+### Intelligent Suggestion Engine
+
+**Pattern Recognition**:
+- **Similar Features**: Identify features with similar functionality
+- **Complementary Features**: Suggest features that enhance existing ones
+- **Missing Features**: Recommend features based on user patterns
+- **Optimization Opportunities**: Suggest improvements to existing features
+
+**Context-Aware Suggestions**:
+- **User Behavior Analysis**: Base suggestions on user interaction patterns
+- **Industry Standards**: Suggest features common in similar applications
+- **Technology Trends**: Recommend features based on current tech trends
+- **Business Goals**: Align suggestions with business objectives
+
+## Feature Connection Analysis
+
+### Dependency Mapping
+
+**Direct Dependencies**:
+- **Data Dependencies**: Features that share data
+- **Functional Dependencies**: Features that depend on each other's functionality
+- **UI Dependencies**: Features that share UI components
+- **API Dependencies**: Features that share API endpoints
+
+**Indirect Dependencies**:
+- **Workflow Dependencies**: Features that are part of the same user workflow
+- **Business Dependencies**: Features that support the same business process
+- **Technical Dependencies**: Features that share technical infrastructure
+
+### Relationship Types
+
+**Hierarchical Relationships**:
+- **Parent-Child**: Main feature and sub-features
+- **Master-Detail**: Master record and detail records
+- **Category-Item**: Category and items within category
+
+**Lateral Relationships**:
+- **Peer Features**: Features at the same level
+- **Complementary Features**: Features that enhance each other
+- **Alternative Features**: Features that provide similar functionality
+
+**Cross-Cutting Relationships**:
+- **Authentication**: Features that require user authentication
+- **Authorization**: Features that require specific permissions
+- **Auditing**: Features that need audit trails
+- **Notifications**: Features that trigger notifications
+
+## AI Potential Analysis
+
+### Machine Learning Opportunities
+
+**Data Analysis Features**:
+- **User Behavior Analytics**: Analyze user interaction patterns
+- **Predictive Analytics**: Predict user actions and preferences
+- **Recommendation Systems**: Suggest content or actions
+- **Anomaly Detection**: Detect unusual patterns or behaviors
+
+**Natural Language Processing**:
+- **Chat Support**: Intelligent chat assistance
+- **Content Analysis**: Analyze and categorize content
+- **Sentiment Analysis**: Understand user sentiment
+- **Language Translation**: Multi-language support
+
+**Computer Vision**:
+- **Image Recognition**: Identify objects in images
+- **Document Processing**: Extract data from documents
+- **Quality Control**: Visual quality assessment
+- **Accessibility**: Visual accessibility features
+
+### Automation Opportunities
+
+**Process Automation**:
+- **Workflow Automation**: Automate repetitive processes
+- **Data Entry Automation**: Reduce manual data entry
+- **Report Generation**: Automated report creation
+- **Scheduling**: Intelligent scheduling and reminders
+
+**Smart Features**:
+- **Auto-completion**: Intelligent form completion
+- **Smart Defaults**: Context-aware default values
+- **Predictive Input**: Anticipate user input
+- **Context Switching**: Automatic context adaptation
+
+## Implementation Strategy
+
+### Feature Prioritization Matrix
+
+**Impact vs. Effort Analysis**:
+- **High Impact, Low Effort**: Quick wins (implement first)
+- **High Impact, High Effort**: Major projects (plan carefully)
+- **Low Impact, Low Effort**: Fill-ins (implement when time allows)
+- **Low Impact, High Effort**: Avoid (not worth the effort)
+
+**User Value Assessment**:
+- **Core Features**: Essential for basic functionality
+- **Enhancement Features**: Improve user experience
+- **Power User Features**: Advanced functionality
+- **Nice-to-Have Features**: Optional improvements
+
+### Technical Feasibility Analysis
+
+**Implementation Complexity**:
+- **Simple**: Straightforward implementation
+- **Moderate**: Requires some planning and effort
+- **Complex**: Requires significant development effort
+- **Very Complex**: Requires major architectural changes
+
+**Resource Requirements**:
+- **Development Time**: Estimated development effort
+- **Technical Skills**: Required technical expertise
+- **Infrastructure**: Required infrastructure changes
+- **Third-Party Services**: External service dependencies
+
+## Suggestion Generation Process
+
+### Input Analysis
+
+**Feature Context**:
+- **Current Features**: Analyze existing functionality
+- **User Feedback**: Consider user suggestions and complaints
+- **Usage Analytics**: Analyze feature usage patterns
+- **Competitive Analysis**: Compare with similar applications
+
+**Business Context**:
+- **Business Goals**: Align with business objectives
+- **Market Trends**: Consider market direction
+- **User Needs**: Address user pain points
+- **Revenue Impact**: Consider revenue potential
+
+### Suggestion Categories
+
+**Functional Suggestions**:
+- **New Features**: Completely new functionality
+- **Feature Enhancements**: Improvements to existing features
+- **Feature Combinations**: Combining existing features
+- **Feature Variations**: Different versions of existing features
+
+**Technical Suggestions**:
+- **Performance Improvements**: Optimize existing features
+- **Security Enhancements**: Improve security measures
+- **Scalability Improvements**: Handle increased load
+- **Integration Opportunities**: Connect with external systems
+
+**User Experience Suggestions**:
+- **UI/UX Improvements**: Better user interface design
+- **Workflow Optimizations**: Streamline user processes
+- **Accessibility Features**: Improve accessibility
+- **Personalization**: Customize user experience
+
+### Suggestion Validation
+
+**Feasibility Check**:
+- **Technical Feasibility**: Can it be implemented?
+- **Resource Availability**: Are resources available?
+- **Timeline Constraints**: Does it fit the timeline?
+- **Risk Assessment**: What are the risks?
+
+**Value Assessment**:
+- **User Value**: Does it provide user value?
+- **Business Value**: Does it provide business value?
+- **ROI Analysis**: What's the return on investment?
+- **Competitive Advantage**: Does it provide competitive advantage?
+
+## Advanced Reasoning Patterns
+
+### Pattern Recognition Algorithms
+
+**Feature Pattern Matching**:
+- **Similarity Analysis**: Find similar features across applications
+- **Usage Pattern Analysis**: Identify common usage patterns
+- **Success Pattern Analysis**: Identify patterns in successful features
+- **Failure Pattern Analysis**: Identify patterns in failed features
+
+**Predictive Modeling**:
+- **User Behavior Prediction**: Predict user actions
+- **Feature Success Prediction**: Predict feature success
+- **Resource Requirement Prediction**: Predict resource needs
+- **Timeline Prediction**: Predict implementation timelines
+
+### Context-Aware Reasoning
+
+**Dynamic Context Adaptation**:
+- **User Context**: Adapt to user preferences and behavior
+- **Business Context**: Adapt to business requirements
+- **Technical Context**: Adapt to technical constraints
+- **Market Context**: Adapt to market conditions
+
+**Multi-Dimensional Analysis**:
+- **User Perspective**: Analyze from user viewpoint
+- **Business Perspective**: Analyze from business viewpoint
+- **Technical Perspective**: Analyze from technical viewpoint
+- **Market Perspective**: Analyze from market viewpoint
+
+## Quality Assurance
+
+### Suggestion Quality Metrics
+
+**Relevance Score**:
+- **User Relevance**: How relevant to users?
+- **Business Relevance**: How relevant to business?
+- **Technical Relevance**: How technically sound?
+- **Market Relevance**: How relevant to market?
+
+**Feasibility Score**:
+- **Implementation Feasibility**: Can it be implemented?
+- **Resource Feasibility**: Are resources available?
+- **Timeline Feasibility**: Does it fit timeline?
+- **Risk Feasibility**: Are risks acceptable?
+
+### Continuous Improvement
+
+**Feedback Integration**:
+- **User Feedback**: Incorporate user feedback
+- **Stakeholder Feedback**: Incorporate stakeholder feedback
+- **Technical Feedback**: Incorporate technical feedback
+- **Market Feedback**: Incorporate market feedback
+
+**Learning and Adaptation**:
+- **Success Analysis**: Analyze successful suggestions
+- **Failure Analysis**: Analyze failed suggestions
+- **Pattern Learning**: Learn from patterns
+- **Algorithm Improvement**: Improve suggestion algorithms
+
+---
+
+**Success Criteria**: Accurate feature analysis, relevant suggestions, intelligent recommendations, and continuous improvement through learning and adaptation.