@agentskillkit/agent-skills 1.0.1

package/docs/awf-user-guide.md

@@ -0,0 +1,436 @@
+# 📖 AWF User Guide - Hướng dẫn sử dụng cho người mới
+
+> **AWF (Antigravity Workflow Framework)** giúp bạn làm app mà không cần biết code.
+> Bạn chỉ cần nói ý tưởng, AI sẽ lo phần còn lại.
+
+---
+
+## 🎯 AWF dùng để làm gì?
+
+| Bạn muốn... | AWF giúp bạn... |
+|-------------|-----------------|
+| Làm app mới | Từ ý tưởng → App hoàn chỉnh |
+| Thêm tính năng | Thiết kế → Code → Test tự động |
+| Sửa lỗi | Tìm lỗi → Sửa → Kiểm tra |
+| Deploy lên server | Cấu hình → Đẩy lên → Theo dõi |
+
+---
+
+## 🗺️ Bản đồ các lệnh AWF
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                           AWF WORKFLOW MAP                                  │
+├─────────────────────────────────────────────────────────────────────────────┤
+│                                                                             │
+│  ╔═══════════════════════════════════════════════════════════════════════╗  │
+│  ║                    🌟 KHỞI ĐẦU & TÌM HIỂU                             ║  │
+│  ╠═══════════════════════════════════════════════════════════════════════╣  │
+│  ║  /brainstorm  │  /init      │  /recap       │  /next                  ║  │
+│  ║  Bàn ý tưởng  │  Tạo mới    │  Nhớ lại      │  Bước tiếp              ║  │
+│  ╚═══════════════════════════════════════════════════════════════════════╝  │
+│                              │                                              │
+│                              ▼                                              │
+│  ╔═══════════════════════════════════════════════════════════════════════╗  │
+│  ║                    🎯 THIẾT KẾ & LẬP KẾ HOẠCH                         ║  │
+│  ╠═══════════════════════════════════════════════════════════════════════╣  │
+│  ║  /plan                    │  /visualize                               ║  │
+│  ║  Lên kế hoạch chi tiết    │  Thiết kế giao diện                       ║  │
+│  ╚═══════════════════════════════════════════════════════════════════════╝  │
+│                              │                                              │
+│                              ▼                                              │
+│  ╔═══════════════════════════════════════════════════════════════════════╗  │
+│  ║                    💻 VIẾT CODE & CHẠY THỬ                            ║  │
+│  ╠═══════════════════════════════════════════════════════════════════════╣  │
+│  ║  /code         │  /run          │  /test                              ║  │
+│  ║  Viết code     │  Chạy app      │  Kiểm tra                           ║  │
+│  ╚═══════════════════════════════════════════════════════════════════════╝  │
+│                              │                                              │
+│                              ▼                                              │
+│  ╔═══════════════════════════════════════════════════════════════════════╗  │
+│  ║                    🚀 TRIỂN KHAI & BẢO TRÌ                            ║  │
+│  ╠═══════════════════════════════════════════════════════════════════════╣  │
+│  ║  /deploy    │  /debug     │  /refactor  │  /audit    │  /rollback    ║  │
+│  ║  Đưa lên    │  Sửa lỗi    │  Dọn dẹp    │  Kiểm tra  │  Hoàn tác     ║  │
+│  ╚═══════════════════════════════════════════════════════════════════════╝  │
+│                              │                                              │
+│                              ▼                                              │
+│  ╔═══════════════════════════════════════════════════════════════════════╗  │
+│  ║                    💾 LƯU TRỮ & CẬP NHẬT                              ║  │
+│  ╠═══════════════════════════════════════════════════════════════════════╣  │
+│  ║  /save-brain              │  /awf-update                              ║  │
+│  ║  Lưu kiến thức            │  Cập nhật AWF                             ║  │
+│  ╚═══════════════════════════════════════════════════════════════════════╝  │
+│                                                                             │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+# 📚 3 KỊCH BẢN SỬ DỤNG AWF
+
+---
+
+## 🆕 KỊCH BẢN 1: Tạo App Mới Từ Đầu
+
+> **Tình huống:** Bạn có ý tưởng và muốn làm app từ con số 0.
+
+### Luồng hoạt động:
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                                                                             │
+│   BẠN CÓ Ý TƯỞNG                                                            │
+│   "Em muốn làm app quản lý tiệm cà phê"                                     │
+│          │                                                                  │
+│          ▼                                                                  │
+│   ┌─────────────────────────────────────────────────────────────────────┐   │
+│   │ BƯỚC 1: /brainstorm (Nếu ý tưởng còn mơ hồ)                         │   │
+│   │                                                                     │   │
+│   │ AI sẽ hỏi:                                                          │   │
+│   │ • "App giải quyết vấn đề gì?"                                       │   │
+│   │ • "Ai sẽ dùng? Chủ tiệm hay nhân viên?"                             │   │
+│   │ • "Có muốn em tìm xem thị trường có app tương tự không?"            │   │
+│   │                                                                     │   │
+│   │ → Output: BRIEF.md (Tóm tắt ý tưởng)                                │   │
+│   └─────────────────────────────────────────────────────────────────────┘   │
+│          │                                                                  │
+│          ▼                                                                  │
+│   ┌─────────────────────────────────────────────────────────────────────┐   │
+│   │ BƯỚC 2: /init (Tạo dự án)                                           │   │
+│   │                                                                     │   │
+│   │ AI sẽ hỏi:                                                          │   │
+│   │ • "Loại app: Website / Web App / Mobile?"                           │   │
+│   │ • "Tên project?"                                                    │   │
+│   │                                                                     │   │
+│   │ AI TỰ LÀM (bạn không cần biết):                                     │   │
+│   │ • Cài đặt công nghệ phù hợp                                         │   │
+│   │ • Tạo cấu trúc thư mục                                              │   │
+│   │ • Cài đặt Git, ESLint, Prettier                                     │   │
+│   │                                                                     │   │
+│   │ → Output: Project sẵn sàng để code                                  │   │
+│   └─────────────────────────────────────────────────────────────────────┘   │
+│          │                                                                  │
+│          ▼                                                                  │
+│   ┌─────────────────────────────────────────────────────────────────────┐   │
+│   │ BƯỚC 3: /plan (Lên kế hoạch tính năng)                              │   │
+│   │                                                                     │   │
+│   │ AI sẽ hỏi:                                                          │   │
+│   │ • "Có cần đăng nhập không?"                                         │   │
+│   │ • "Quản lý những gì? (Nhân viên, đơn hàng, menu...)"                │   │
+│   │ • "Có cần báo cáo doanh thu không?"                                 │   │
+│   │                                                                     │   │
+│   │ → Output: Thiết kế chi tiết (PRD, Database schema)                  │   │
+│   └─────────────────────────────────────────────────────────────────────┘   │
+│          │                                                                  │
+│          ▼                                                                  │
+│   ┌─────────────────────────────────────────────────────────────────────┐   │
+│   │ BƯỚC 4: /visualize (Thiết kế giao diện)                             │   │
+│   │                                                                     │   │
+│   │ AI sẽ hỏi:                                                          │   │
+│   │ • "Màn hình nào cần làm trước?"                                     │   │
+│   │ • "Trên màn hình có những gì?"                                      │   │
+│   │ • "Khi click vào thì chuyển đi đâu?"                                │   │
+│   │                                                                     │   │
+│   │ → Output: File UI code sẵn sàng                                     │   │
+│   └─────────────────────────────────────────────────────────────────────┘   │
+│          │                                                                  │
+│          ▼                                                                  │
+│   ┌─────────────────────────────────────────────────────────────────────┐   │
+│   │ BƯỚC 5: /code (Viết logic)                                          │   │
+│   │                                                                     │   │
+│   │ AI TỰ LÀM:                                                          │   │
+│   │ • Viết code backend (xử lý dữ liệu)                                 │   │
+│   │ • Kết nối database                                                  │   │
+│   │ • Xử lý đăng nhập, bảo mật                                          │   │
+│   │                                                                     │   │
+│   │ QUY TẮC VÀNG:                                                       │   │
+│   │ • Chỉ làm những gì bạn yêu cầu                                      │   │
+│   │ • Không tự ý deploy hay thay đổi lớn                                │   │
+│   └─────────────────────────────────────────────────────────────────────┘   │
+│          │                                                                  │
+│          ▼                                                                  │
+│   ┌─────────────────────────────────────────────────────────────────────┐   │
+│   │ BƯỚC 6: /run → /test (Chạy và kiểm tra)                             │   │
+│   │                                                                     │   │
+│   │ • /run: Chạy app lên xem thử                                        │   │
+│   │ • /test: Kiểm tra xem có lỗi gì không                               │   │
+│   │                                                                     │   │
+│   │ Nếu có lỗi → /debug để sửa                                          │   │
+│   └─────────────────────────────────────────────────────────────────────┘   │
+│          │                                                                  │
+│          ▼                                                                  │
+│   ┌─────────────────────────────────────────────────────────────────────┐   │
+│   │ BƯỚC 7: /deploy (Đưa lên internet)                                  │   │
+│   │                                                                     │   │
+│   │ AI TỰ LÀM:                                                          │   │
+│   │ • Cấu hình hosting                                                  │   │
+│   │ • Thiết lập domain                                                  │   │
+│   │ • SEO, Analytics, bảo mật                                           │   │
+│   │                                                                     │   │
+│   │ → Output: App live trên internet!                                   │   │
+│   └─────────────────────────────────────────────────────────────────────┘   │
+│          │                                                                  │
+│          ▼                                                                  │
+│   ┌─────────────────────────────────────────────────────────────────────┐   │
+│   │ BƯỚC 8: /save-brain (Lưu kiến thức)                                 │   │
+│   │                                                                     │   │
+│   │ Lưu lại tất cả để mai còn nhớ:                                      │   │
+│   │ • Cấu trúc app                                                      │   │
+│   │ • Các API đã tạo                                                    │   │
+│   │ • Quy tắc nghiệp vụ                                                 │   │
+│   └─────────────────────────────────────────────────────────────────────┘   │
+│                                                                             │
+│   🎉 HOÀN THÀNH! App của bạn đã live!                                       │
+│                                                                             │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+### Tóm tắt luồng:
+```
+/brainstorm → /init → /plan → /visualize → /code → /run → /test → /deploy → /save-brain
+```
+
+---
+
+## 📦 KỊCH BẢN 2: Thêm AWF vào App Có Sẵn
+
+> **Tình huống:** Bạn đã có app đang chạy, muốn dùng AWF để phát triển tiếp.
+
+### Luồng hoạt động:
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                                                                             │
+│   BẠN CÓ APP SẴN                                                            │
+│   (Đã có code, đang chạy)                                                   │
+│          │                                                                  │
+│          ▼                                                                  │
+│   ┌─────────────────────────────────────────────────────────────────────┐   │
+│   │ BƯỚC 1: Cài đặt AWF vào project                                     │   │
+│   │                                                                     │   │
+│   │ Chạy lệnh cài đặt:                                                  │   │
+│   │ curl -fsSL https://raw.githubusercontent.com/.../install.sh | bash  │   │
+│   │                                                                     │   │
+│   │ AWF sẽ tạo file GEMINI.md trong project                             │   │
+│   └─────────────────────────────────────────────────────────────────────┘   │
+│          │                                                                  │
+│          ▼                                                                  │
+│   ┌─────────────────────────────────────────────────────────────────────┐   │
+│   │ BƯỚC 2: /recap (Cho AI hiểu app của bạn)                            │   │
+│   │                                                                     │   │
+│   │ AI sẽ TỰ ĐỘNG:                                                      │   │
+│   │ • Đọc cấu trúc thư mục                                              │   │
+│   │ • Phân tích code hiện có                                            │   │
+│   │ • Hiểu tech stack đang dùng                                         │   │
+│   │ • Xem git history                                                   │   │
+│   │                                                                     │   │
+│   │ AI sẽ TÓM TẮT:                                                      │   │
+│   │ "📋 Em hiểu app của anh là [X], dùng [tech], có [features]..."      │   │
+│   └─────────────────────────────────────────────────────────────────────┘   │
+│          │                                                                  │
+│          ▼                                                                  │
+│   ┌─────────────────────────────────────────────────────────────────────┐   │
+│   │ BƯỚC 3: /save-brain (Lưu kiến thức về app)                          │   │
+│   │                                                                     │   │
+│   │ Quan trọng! Để AI "nhớ" app của bạn:                                │   │
+│   │ • Cấu trúc database                                                 │   │
+│   │ • Các API endpoints                                                 │   │
+│   │ • Quy tắc nghiệp vụ đặc biệt                                        │   │
+│   │                                                                     │   │
+│   │ → Từ giờ AI sẽ hiểu context của app                                 │   │
+│   └─────────────────────────────────────────────────────────────────────┘   │
+│          │                                                                  │
+│          ▼                                                                  │
+│   ┌─────────────────────────────────────────────────────────────────────┐   │
+│   │ BƯỚC 4: Sẵn sàng! Bắt đầu phát triển                                │   │
+│   │                                                                     │   │
+│   │ Giờ bạn có thể dùng:                                                │   │
+│   │ • /plan - Thêm tính năng mới                                        │   │
+│   │ • /debug - Sửa lỗi                                                  │   │
+│   │ • /refactor - Dọn dẹp code cũ                                       │   │
+│   │ • /audit - Kiểm tra bảo mật, hiệu năng                              │   │
+│   └─────────────────────────────────────────────────────────────────────┘   │
+│                                                                             │
+│   🎉 AWF đã sẵn sàng hỗ trợ app của bạn!                                    │
+│                                                                             │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+### Tóm tắt luồng:
+```
+Cài AWF → /recap → /save-brain → Sẵn sàng dùng các lệnh khác
+```
+
+---
+
+## ➕ KỊCH BẢN 3: Thêm Tính Năng Mới vào App
+
+> **Tình huống:** App đã có, bạn muốn thêm tính năng mới.
+
+### Luồng hoạt động:
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                                                                             │
+│   BẠN MUỐN THÊM TÍNH NĂNG                                                   │
+│   "Em muốn thêm tính năng báo cáo doanh thu"                                │
+│          │                                                                  │
+│          ▼                                                                  │
+│   ┌─────────────────────────────────────────────────────────────────────┐   │
+│   │ BƯỚC 0: /recap (Nếu lâu không làm việc với app)                     │   │
+│   │                                                                     │   │
+│   │ AI sẽ nhắc lại:                                                     │   │
+│   │ • App đang làm gì                                                   │   │
+│   │ • Lần cuối làm đến đâu                                              │   │
+│   │ • Có việc dở dang không                                             │   │
+│   │                                                                     │   │
+│   │ (Bỏ qua nếu vừa mới làm việc với app)                               │   │
+│   └─────────────────────────────────────────────────────────────────────┘   │
+│          │                                                                  │
+│          ▼                                                                  │
+│   ┌─────────────────────────────────────────────────────────────────────┐   │
+│   │ BƯỚC 1: /brainstorm HOẶC /plan                                      │   │
+│   │                                                                     │   │
+│   │ Chọn /brainstorm nếu:                                               │   │
+│   │ • Chưa chắc tính năng cần gì                                        │   │
+│   │ • Muốn thảo luận nhiều hướng                                        │   │
+│   │ • Cần research xem người ta làm thế nào                             │   │
+│   │                                                                     │   │
+│   │ Chọn /plan nếu:                                                     │   │
+│   │ • Đã biết rõ tính năng cần gì                                       │   │
+│   │ • Chỉ cần AI thiết kế chi tiết                                      │   │
+│   │                                                                     │   │
+│   │ AI sẽ hỏi về tính năng và tạo thiết kế                              │   │
+│   └─────────────────────────────────────────────────────────────────────┘   │
+│          │                                                                  │
+│          ▼                                                                  │
+│   ┌─────────────────────────────────────────────────────────────────────┐   │
+│   │ BƯỚC 2: /visualize (Nếu tính năng có giao diện)                     │   │
+│   │                                                                     │   │
+│   │ AI sẽ hỏi về màn hình:                                              │   │
+│   │ • "Màn hình báo cáo hiển thị những gì?"                             │   │
+│   │ • "Có biểu đồ không? Loại nào?"                                     │   │
+│   │ • "Có nút export PDF không?"                                        │   │
+│   │                                                                     │   │
+│   │ → Tạo UI cho tính năng mới                                          │   │
+│   └─────────────────────────────────────────────────────────────────────┘   │
+│          │                                                                  │
+│          ▼                                                                  │
+│   ┌─────────────────────────────────────────────────────────────────────┐   │
+│   │ BƯỚC 3: /code (Viết code tính năng)                                 │   │
+│   │                                                                     │   │
+│   │ AI sẽ:                                                              │   │
+│   │ • Viết code cho tính năng mới                                       │   │
+│   │ • Kết nối với code cũ                                               │   │
+│   │ • Đảm bảo không phá hỏng gì                                         │   │
+│   │                                                                     │   │
+│   │ QUY TẮC: Thay đổi tối thiểu, không ảnh hưởng code đang chạy tốt     │   │
+│   └─────────────────────────────────────────────────────────────────────┘   │
+│          │                                                                  │
+│          ▼                                                                  │
+│   ┌─────────────────────────────────────────────────────────────────────┐   │
+│   │ BƯỚC 4: /run → /test (Kiểm tra)                                     │   │
+│   │                                                                     │   │
+│   │ • /run: Chạy app, test tính năng mới                                │   │
+│   │ • /test: Kiểm tra tính năng mới VÀ tính năng cũ                     │   │
+│   │   (đảm bảo không phá gì)                                            │   │
+│   │                                                                     │   │
+│   │ Nếu lỗi → /debug                                                    │   │
+│   └─────────────────────────────────────────────────────────────────────┘   │
+│          │                                                                  │
+│          ▼                                                                  │
+│   ┌─────────────────────────────────────────────────────────────────────┐   │
+│   │ BƯỚC 5: /deploy (Cập nhật lên server)                               │   │
+│   │                                                                     │   │
+│   │ AI sẽ:                                                              │   │
+│   │ • Đẩy code mới lên server                                           │   │
+│   │ • Không downtime (app vẫn chạy)                                     │   │
+│   │ • Backup phòng trường hợp cần rollback                              │   │
+│   └─────────────────────────────────────────────────────────────────────┘   │
+│          │                                                                  │
+│          ▼                                                                  │
+│   ┌─────────────────────────────────────────────────────────────────────┐   │
+│   │ BƯỚC 6: /save-brain (Lưu kiến thức mới)                             │   │
+│   │                                                                     │   │
+│   │ Cập nhật kiến thức về app:                                          │   │
+│   │ • Tính năng mới đã thêm                                             │   │
+│   │ • API mới (nếu có)                                                  │   │
+│   │ • Quy tắc nghiệp vụ mới                                             │   │
+│   └─────────────────────────────────────────────────────────────────────┘   │
+│                                                                             │
+│   🎉 TÍNH NĂNG MỚI ĐÃ LIVE!                                                 │
+│                                                                             │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+### Tóm tắt luồng:
+```
+(/recap) → /brainstorm hoặc /plan → /visualize → /code → /run → /test → /deploy → /save-brain
+```
+
+---
+
+## 🆘 KHI GẶP KHÓ KHĂN
+
+### Không biết làm gì tiếp?
+```
+Gõ: /next
+→ AI sẽ phân tích và gợi ý bước tiếp theo
+```
+
+### Bị lỗi?
+```
+Gõ: /debug
+→ AI sẽ tìm và sửa lỗi
+```
+
+### Muốn quay lại phiên bản cũ?
+```
+Gõ: /rollback
+→ AI sẽ giúp khôi phục
+```
+
+### Kiểm tra app có vấn đề gì không?
+```
+Gõ: /audit
+→ AI kiểm tra bảo mật, hiệu năng, code quality
+```
+
+---
+
+## 📊 BẢNG TÓM TẮT TẤT CẢ LỆNH
+
+| Lệnh | Khi nào dùng | Output |
+|------|--------------|--------|
+| `/brainstorm` | Có ý tưởng mơ hồ, cần thảo luận | BRIEF.md |
+| `/init` | Tạo project mới | Project sẵn sàng |
+| `/recap` | Quên đang làm gì, quay lại sau lâu | Tóm tắt context |
+| `/next` | Không biết bước tiếp theo | Gợi ý cụ thể |
+| `/plan` | Thiết kế tính năng | PRD, Schema |
+| `/visualize` | Thiết kế giao diện | UI code |
+| `/code` | Viết logic, backend | Code hoàn chỉnh |
+| `/run` | Chạy thử app | App running |
+| `/test` | Kiểm tra có lỗi không | Test results |
+| `/debug` | Sửa lỗi | Bug fixed |
+| `/deploy` | Đưa lên internet | App live |
+| `/refactor` | Dọn dẹp code | Code sạch hơn |
+| `/audit` | Kiểm tra sức khỏe app | Báo cáo |
+| `/rollback` | Quay về phiên bản cũ | Khôi phục |
+| `/save-brain` | Lưu kiến thức cuối ngày | Knowledge saved |
+| `/awf-update` | Cập nhật AWF | AWF mới nhất |
+
+---
+
+## 💡 MẸO SỬ DỤNG
+
+1. **Mỗi sáng:** `/recap` để nhớ lại
+2. **Cuối ngày:** `/save-brain` để mai không quên
+3. **Khi stuck:** `/next` để được gợi ý
+4. **Trước release:** `/audit` + `/test`
+5. **Nói tự nhiên:** AI sẽ hỏi lại nếu chưa hiểu
+
+---
+
+*AWF - Antigravity Workflow Framework*
+*Your ideas, our engineering.*

package/docs/context-engineering-guide.md

@@ -0,0 +1,99 @@
+---
+name: context-engineering-guide
+description: Best practices for managing AI agent context windows efficiently
+---
+
+# Context Engineering Guide
+
+> **Bài học từ ClaudeKit-Skills REFACTOR.md**
+
+## 🎯 Core Principle
+
+> "Context engineering isn't about loading more information. It's about loading the **right information at the right time**."
+
+## ❌ Sai lầm phổ biến
+
+```
+Skills ≠ Documentation dumps
+1,000+ lines SKILL.md = Context sludge
+Loading 5-7 skills = 5,000-7,000 tokens wasted
+```
+
+## ✅ Progressive Disclosure Architecture
+
+### 3-Tier Loading System
+
+| Tier | Content | Size | When Loaded |
+|------|---------|------|-------------|
+| **1. Metadata** | YAML frontmatter (name, description) | ~100 words | Always |
+| **2. Entry Point** | SKILL.md body | <200 lines | When skill activates |
+| **3. References** | references/*.md, scripts/*.py | 200-300 lines each | On-demand |
+
+### 200-Line Rule
+
+```
+SKILL.md         < 200 lines  (entry point + navigation)
+references/*.md  < 300 lines  (detailed docs)
+scripts/*.py     < 300 lines  (executable code)
+```
+
+**Nếu > 200 lines → Split thành multiple files**
+
+## 📊 Kết quả đo được
+
+| Metric | Before | After | Improvement |
+|--------|--------|-------|-------------|
+| Token efficiency | 1x | 4.8x | **380% better** |
+| Activation time | 500ms | <100ms | **5x faster** |
+| Relevant info ratio | 10% | 90% | **9x more relevant** |
+| Initial context load | 15,000 lines | 2,200 lines | **85% reduction** |
+
+## 🔧 Workflow-Centric Skills
+
+### ❌ Tool-centric (bad)
+```
+cloudflare/        → "Cloudflare docs"
+cloudflare-workers/→ "Workers docs"
+docker/            → "Docker docs"
+gcloud/            → "GCloud docs"
+```
+
+### ✅ Workflow-centric (good)
+```
+devops/            → "Deploy serverless functions"
+  ├── references/cloudflare.md
+  ├── references/docker.md
+  └── references/gcloud.md
+```
+
+**Key insight:** Skills là *khả năng thực hiện workflow* chứ không phải *documentation*
+
+## 📝 Writing Style
+
+| ❌ Avoid | ✅ Prefer |
+|----------|----------|
+| "You should do X" | "To accomplish X, do Y" |
+| "If you need to..." | "When X is required, do Y" |
+| Second person | Imperative/infinitive form |
+
+## 🧪 Testing Cold Start
+
+1. Clear context completely
+2. Activate the skill
+3. Measure lines loaded
+
+**Target:** < 500 lines on first activation
+
+## 📋 Checklist for New Skills
+
+- [ ] SKILL.md < 200 lines
+- [ ] Each reference file < 300 lines
+- [ ] Description contains use cases (for auto-activation)
+- [ ] References folder for detailed docs
+- [ ] Scripts folder for executable code
+- [ ] No duplicate info between SKILL.md and references
+
+## 🔗 Related Skills
+
+- `skill-creator` - Guide for creating effective skills
+- `context-engineering` - Advanced context optimization techniques

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@agentskillkit/agent-skills",
+  "version": "1.0.1",
+  "description": "The Premium Agent Skills Kit for Enterprise",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agentskillkit/agent-skills.git"
+  },
+  "homepage": "https://github.com/agentskillkit/agent-skills",
+  "bin": {
+    "agent-skills-kit": "./packages/cli/bin/ag-smart.js",
+    "ag-smart": "./packages/cli/bin/ag-smart.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "checklist": "python .agent/scripts/checklist.py .",
+    "scan:security": "python .agent/skills/vulnerability-scanner/scripts/security_scan.py .",
+    "lint": "python .agent/skills/lint-and-validate/scripts/lint_runner.py .",
+    "learn": "node packages/cli/lib/learn.js"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "skills",
+    "self-learning",
+    "agent-skills-kit",
+    "enterprise"
+  ],
+  "author": "agentskillkit <agentskillkit@gmail.com>",
+  "license": "UNLICENSED",
+  "devDependencies": {
+    "eslint": "^9.0.0",
+    "prettier": "^3.0.0"
+  },
+  "dependencies": {
+    "js-yaml": "^4.1.1"
+  }
+}

package/packages/cli/.agent/knowledge/lessons-learned.yaml

@@ -0,0 +1,32 @@
+lessons:
+  - id: LEARN-001
+    pattern: TODO
+    message: Please
+    severity: WARNING
+    category: code-quality
+    source: manual
+    hitCount: 0
+    lastHit: null
+    autoEscalated: false
+    addedAt: '2026-01-24T20:54:57.262Z'
+  - id: LEARN-002
+    pattern: console.log
+    message: 'No'
+    severity: ERROR
+    category: general
+    source: manual
+    hitCount: 20
+    lastHit: '2026-01-24T21:02:58.265Z'
+    autoEscalated: false
+    addedAt: '2026-01-24T20:59:54.591Z'
+  - id: LEARN-003
+    pattern: var\s+
+    message: Use
+    severity: WARNING
+    category: general
+    source: manual
+    hitCount: 0
+    lastHit: null
+    autoEscalated: false
+    addedAt: '2026-01-24T21:17:40.051Z'
+version: 1