codymaster 4.1.0

package/CHANGELOG.md

@@ -0,0 +1,50 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+Categories: 🚀 **Improvements** | 🐛 **Bug Fixes**
+
+## [4.1.0] - 2026-03-23
+
+### 🚀 Improvements
+- Token Optimization Phase 1 — `GEMINI.md` reduced from 32 `@` imports to 3 essential skills, saving 92% tokens per turn (~100K → ~8K)
+- Token Optimization Phase 2 — Top 5 largest skills slimmed by 72-84% (105K bytes saved total):
+  - `cm-project-bootstrap` 40K → 6.6K, `cm-ux-master` 27K → 5.6K, `cm-safe-deploy` 23K → 4.1K, `cro-methodology` 22K → 4.9K, `cm-ads-tracker` 19K → 5.3K
+- Progressive Disclosure Templates — 10 template files extracted to `templates/` directories for on-demand loading via `view_file`, eliminating accuracy trade-offs from slimming
+- Vibe Coding landing page (`vibe-coding.html`) — guide for non-developers
+- Parallel Coding landing page (`parallel-coding.html`) — side-by-side comparison with/without CodyMaster
+
+---
+
+## [4.0.0] - 2026-03-23
+
+### 🚀 Improvements
+- Project Level System (L0-L3) — auto-detects complexity and scales workflow depth
+- Shared Helpers Pattern — `skills/_shared/helpers.md` with 6 reusable sections (~750-1000 tokens saved per skill)
+- Role Labels — 6 key skills now carry explicit roles (Lead Developer, Strategic Analyst, Product Manager, QA Lead, Test Engineer, Release Engineer)
+- Gate Scoring — `cm-quality-gate` now outputs numeric scores per gate (≥80 PASS, 60-79 WARN, <60 FAIL)
+- Requirement Tracing — FR/NFR IDs in `cm-planning` for L2+ projects
+- Outputs Convention — standardized `.cm/outputs/` directory structure
+- Skill Gap Detector — auto-detects missing skills during planning and execution
+- Release Pipeline — automatic version bumping and changelog generation in `cm-safe-deploy`
+
+### 🐛 Bug Fixes
+- Remove `skill-creator-ultra` from skill index, CLI, FAQ, and i18n files (replaced by on-demand `cm-skill-mastery` guidance)
+
+---
+
+## [3.4.0] - 2026-03-23
+
+### 🚀 Improvements
+- Multi-country upgrade for VN, TH, PH
+- Smart Import Engine with configurable scoring rules
+- Design system extraction with Harvester v5
+- 34-skill CodyMaster kit with auto-chaining
+- Safe Deploy Pipeline v2 with 9-gate sequential pipeline
+- DocKit changelog support for closed-loop releases
+- i18n framework with 4-language support (vi, en, th, ph)
+
+### 🐛 Bug Fixes
+- Fix FAQ card spacing on mobile layout
+- Fix i18n key parity for Thai language files
+- Fix employee period score calculation edge cases

package/README.md

@@ -0,0 +1,285 @@
+<div align="center">
+
+[English](README.md) | [Tiếng Việt](README-vi.md) | [中文](README-zh.md) | [Русский](README-ru.md) | [한국어](README-ko.md) | [हिन्दी](README-hi.md)
+
+# 🧠 CodyMaster
+
+### Your AI Agent is smart. CodyMaster makes it *wise*.
+
+**34 Skills · 11 Commands · 1 Plugin · 7+ Platforms · 6 Languages**
+
+<p align="center">
+  <img alt="Version" src="https://img.shields.io/badge/version-4.0.0-blue.svg?cacheSeconds=2592000" />
+  <img alt="Skills" src="https://img.shields.io/badge/skills-34-success.svg" />
+  <img alt="Platforms" src="https://img.shields.io/badge/platforms-7+-orange.svg" />
+  <img alt="Open Source" src="https://img.shields.io/badge/license-MIT-purple.svg" />
+  <a href="https://github.com/tody-agent/codymaster#readme" target="_blank">
+    <img alt="Documentation" src="https://img.shields.io/badge/documentation-yes-brightgreen.svg" />
+  </a>
+</p>
+
+![CodyMaster Kanban Dashboard](assets/images/dashboard.png)
+
+### 🌟 If CodyMaster saves you time, give it a [Star](https://github.com/tody-agent/codymaster)! 🌟
+
+</div>
+
+---
+
+## 🛑 The Problem Nobody Talks About
+
+You installed an AI coding agent. It's *brilliant*. It writes code faster than any human.
+
+But then reality hits:
+
+| 😤 What Actually Happens | 💀 The Real Cost |
+|--------------------------|-----------------|
+| AI designs **differently every single time** — same brand, 3 different styles | Clients think you're 3 different companies |
+| AI fixes one bug, **silently breaks 5 other things** | You redo the same work 3-4 times |
+| AI **forgets everything** between sessions | You re-explain the same codebase every morning |
+| AI writes zero tests, zero docs | Your codebase becomes a house of cards |
+| You install 15 different skills — **none of them talk to each other** | Frankenstein toolkit with zero synergy |
+| Deploy to production = **deploy and pray** 🙏 | Broken deploys at 2 AM, no rollback |
+
+> *"AI gave me 100 hands. But without discipline, those hands created chaos."*
+> — **Tody Le**, Head of Product · 10+ years · Creator of CodyMaster
+
+---
+
+## 🟢 The Solution: An Entire Senior Team in One Kit
+
+CodyMaster isn't just "another AI skills pack." It's **10+ years of product management experience + 6 months of battle-tested vibe coding**, distilled into 34 interconnected skills that work as a **single integrated system**.
+
+When you install CodyMaster, you're not adding skills.
+**You're hiring an entire senior team:**
+
+```mermaid
+graph TD
+    A["🧠 CodyMaster Kit"] --> B["👨‍💻 Senior Developer<br/><i>cm-tdd · cm-debugging · cm-code-review</i>"]
+    A --> C["🎨 UX Lead<br/><i>cm-design-system · cm-ux-master · cm-ui-preview</i>"]
+    A --> D["📋 Product Manager<br/><i>cm-planning · cm-brainstorm-idea · cm-jtbd</i>"]
+    A --> E["🔒 DevOps Engineer<br/><i>cm-safe-deploy · cm-secret-shield · cm-identity-guard</i>"]
+    A --> F["📝 Technical Writer<br/><i>cm-dockit · cm-content-factory</i>"]
+    A --> G["📈 Growth Marketer<br/><i>cm-ads-tracker · cro-methodology</i>"]
+    style A fill:#fbc531,stroke:#e1b12c,color:#2f3640,stroke-width:3px
+    classDef team fill:#2f3640,stroke:#dcdde1,stroke-width:1px,color:#fff;
+    class B,C,D,E,F,G team;
+```
+
+---
+
+## ⚡ What Makes CodyMaster Different
+
+Other skill packs give you loose tools. CodyMaster gives you an **interconnected operating system** for your AI.
+
+### 🔄 Full Lifecycle Coverage (Idea → Production)
+
+No gaps. No manual handoffs. Every phase is covered:
+
+```mermaid
+graph LR
+    A["💡 Idea"] --> B["📋 Plan"]
+    B --> C["🎨 Design"]
+    C --> D["🧪 Test First"]
+    D --> E["💻 Code"]
+    E --> F["🔍 Debug"]
+    F --> G["✅ Quality Gate"]
+    G --> H["🔒 Security Scan"]
+    H --> I["🚀 Deploy"]
+    I --> J["📊 Monitor"]
+    J --> K["📝 Document"]
+    K --> L["🧠 Learn & Improve"]
+    L -.-> A
+    classDef phase fill:#353b48,stroke:#fbc531,stroke-width:2px,color:#fff;
+    class A,B,C,D,E,F,G,H,I,J,K,L phase;
+```
+
+### 🧠 A Brain That Learns From Mistakes
+
+Your AI doesn't just execute — it **remembers and improves**:
+
+- **`cm-continuity`** — Working memory across sessions. AI remembers what went wrong and never repeats the same mistake
+- **`cm-skill-mastery`** — Doesn't know how to do something? It **finds the right skill automatically** and upgrades itself
+- **`cm-deep-search`** — Lost in a 200+ file codebase? Semantic search across everything in seconds
+
+### 🛡️ Multi-Layer Protection (Your Codebase Won't Get Destroyed)
+
+Every line of code passes through multiple safety gates before reaching production:
+
+```mermaid
+flowchart LR
+    subgraph "Layer 1: Write"
+        A["cm-tdd<br/>Tests First"] --> B["cm-code-review"]
+    end
+    subgraph "Layer 2: Secure"
+        B --> C["cm-secret-shield<br/>Leak Scan"] --> D["cm-identity-guard<br/>Right Account"]
+    end
+    subgraph "Layer 3: Isolate"
+        D --> E["cm-git-worktrees<br/>Isolated Branch"]
+    end
+    subgraph "Layer 4: Deploy"
+        E --> F["cm-quality-gate<br/>Evidence Check"] --> G["cm-safe-deploy<br/>Multi-Gate Pipeline"]
+    end
+    style A fill:#e84118,stroke:#c23616,color:#fff
+    style C fill:#e84118,stroke:#c23616,color:#fff
+    style F fill:#0097e6,stroke:#00a8ff,color:#fff
+    style G fill:#4cd137,stroke:#44bd32,color:#fff
+```
+
+> **Result:** Zero leaked secrets. Zero wrong-account deploys. Zero "worked on my machine" failures.
+
+### 🎨 Design System Builder — Even From Old Products
+
+Got a legacy product with no design system? **cm-design-system** scans your website, extracts colors, typography, spacing, and tokens, then rebuilds a proper design system. Preview designs visually with **Pencil.dev** or **Google Stitch** before writing a single line of code.
+
+### 📝 Zero Documentation? No Problem.
+
+Don't know what the old code does? **`cm-dockit`** reads your entire codebase and generates:
+- 📚 Technical architecture docs
+- 📖 User guides & SOPs
+- 🔌 API references
+- 🎯 Persona analysis & JTBD mapping
+- 🌐 Multi-language. SEO-optimized.
+
+**One scan = Complete knowledge base.**
+
+### 📊 Visual Dashboard — See Everything at a Glance
+
+No more guessing. Track every task, every agent, every deployment on a real-time Kanban board. Pipeline progress, token tracker, event log — all on one screen.
+
+---
+
+## 🆚 Scattered Skills vs CodyMaster
+
+| | 😵 15 Random Skills | 🧠 CodyMaster |
+|---|---|---|
+| **Integration** | Each skill is standalone, no shared context | 34 skills that chain, share memory, and communicate |
+| **Lifecycle** | Covers coding only | Covers Idea → Design → Code → Test → Deploy → Docs → Learn |
+| **Memory** | Forgets everything between sessions | 4-tier memory system: Working → Episodic → Semantic → Deep Search |
+| **Safety** | YOLO deploys | 4-layer protection: TDD → Security → Isolation → Multi-gate deploy |
+| **Design** | Random UI every time | Extracts & enforces design system + visual preview |
+| **Documentation** | "Maybe write a README later" | Auto-generates complete docs, SOPs, API refs from code |
+| **Self-improvement** | Static — what you install is what you get | Learns from mistakes, auto-discovers new skills, gets smarter daily |
+| **Maintenance** | Update 15 repos separately | One `git pull` updates everything |
+
+---
+
+## 🦥 Built For Lazy People (Seriously)
+
+We're going to be honest: **CodyMaster was built for lazy people.**
+
+If you want to:
+- ✅ Type a chat message and get a **working product** back
+- ✅ Have your AI **learn from its mistakes** and get better every day
+- ✅ Never setup the same boilerplate twice
+- ✅ Deploy with **confidence** instead of praying
+
+**→ CodyMaster is for you.**
+
+If you prefer:
+- ❌ Manually reviewing every line of AI output
+- ❌ Doing the same setup ritual for every project
+- ❌ Slow, manual deploys with no safety net
+
+**→ CodyMaster is NOT for you.**
+
+---
+
+## 🚀 1-Minute Install
+
+### Claude Code (Recommended)
+```bash
+bash <(curl -fsSL https://raw.githubusercontent.com/tody-agent/codymaster/main/install.sh) --claude
+```
+*Or: `claude plugin marketplace add tody-agent/codymaster` → `claude plugin install cm@codymaster`*
+
+### Cursor IDE
+```
+/add-plugin cody-master
+```
+
+### Gemini CLI / Antigravity
+```bash
+gemini extensions install https://github.com/tody-agent/codymaster
+```
+
+<details>
+<summary><b>Other Platforms: Codex, OpenCode, Kiro, Copilot, Windsurf, Cline</b></summary>
+
+```bash
+# Universal: clone once, copy to any platform
+git clone https://github.com/tody-agent/codymaster.git ~/.cody-master
+
+# Then drop skills into your platform's directory:
+cp -r ~/.cody-master/skills/* .cursor/skills/
+cp -r ~/.cody-master/skills/* .codex/skills/
+cp -r ~/.cody-master/skills/* .kiro/steering/
+cp -r ~/.cody-master/skills/* .opencode/skills/
+cp -r ~/.cody-master/skills/* ~/.gemini/antigravity/skills/
+```
+</details>
+
+---
+
+## 🧰 The 34-Skill Arsenal
+
+| Domain | Skills |
+|--------|--------|
+| 🔧 **Engineering** | `cm-tdd` `cm-debugging` `cm-quality-gate` `cm-test-gate` `cm-code-review` |
+| ⚙️ **Operations** | `cm-safe-deploy` `cm-identity-guard` `cm-secret-shield` `cm-git-worktrees` `cm-terminal` `cm-safe-i18n` |
+| 🎨 **Product & UX** | `cm-planning` `cm-design-system` `cm-ux-master` `cm-ui-preview` `cm-project-bootstrap` `cm-jtbd` `cm-brainstorm-idea` `cm-dockit` `cm-readit` |
+| 📈 **Growth/CRO** | `cm-content-factory` `cm-ads-tracker` `cro-methodology` |
+| 🎯 **Orchestration** | `cm-execution` `cm-continuity` `cm-skill-chain` `cm-skill-mastery` `cm-skill-index` `cm-deep-search` `cm-how-it-work` |
+| 🖥️ **Workflow** | `cm-start` `cm-dashboard` `cm-status` |
+
+---
+
+## 🎮 Commands
+
+```
+/cm:demo         → Interactive onboarding tour
+/cm:bootstrap    → Scaffold a new project from scratch
+/cm:plan         → Plan a feature with analysis
+/cm:build        → Build with strict TDD
+/cm:debug        → Systematic debugging
+/cm:ux           → Design system extraction & UI preview
+/cm:track        → Marketing pixel & tracking setup
+```
+
+---
+
+## 👤 Who Built This
+
+**Tody Le** — Head of Product with 10+ years of experience. Can't write code. Used AI to build real products for 6 months straight. Every skill in this kit was born from a real failure that cost real time and real tears.
+
+> *"34 skills. Each skill is a lesson. Each lesson is a sleepless night. And now, you don't have to go through those nights."*
+
+📖 [Read the full story →](https://cody.todyle.com/story)
+
+---
+
+## 📚 Resources
+
+- 🌍 [Website](https://cody.todyle.com) — Overview & demos
+- 📖 [Documentation](https://cody.todyle.com/docs) — Full deep-dive
+- 🛠️ [Skills Reference](skills/) — Browse all 34 SKILL.md files
+- 📖 [Our Story](https://cody.todyle.com/story) — Why this exists
+
+---
+
+## 🤝 Contributing
+
+1. ⭐ **Star the repo** — it helps more builders find this
+2. Fork → Create `skills/cm-your-skill/SKILL.md`
+3. Submit a Pull Request
+
+---
+
+<div align="center">
+
+*MIT License — Free to use, modify, and distribute.* <br/>
+**Built with ❤️ for the vibe coding community.**
+
+*"Cody" = "Code Đi" (Vietnamese: "Go code!") — just start building.*
+
+</div>

package/adapters/antigravity.js

@@ -0,0 +1,15 @@
+/**
+ * Converts a Universal SKILL.md into Google Antigravity (Gemini) format.
+ * Antigravity relies on `<skills>` blocks in system prompts and explicitly
+ * supports subagent dispatch via the `browser_subagent` or custom endpoints.
+ */
+
+export function buildAntigravityPrompt(skillMeta, context) {
+    return `
+<skills>
+  - ${skillMeta.name}: ${skillMeta.description}
+  To execute, consider using subagents for maximum speed.
+  ${context.join('\n')}
+</skills>
+    `;
+}

package/adapters/claude-code.js

@@ -0,0 +1,17 @@
+/**
+ * Converts a Universal SKILL.md into Claude Code format.
+ * Claude Code uses customized .claude file configurations or project-level prompts.
+ */
+
+export function buildClaudePrompt(skillMeta, context) {
+    return `
+# Skill: ${skillMeta.name}
+${skillMeta.description}
+
+Context values:
+${context.join('\n')}
+
+INSTRUCTIONS:
+You are equipped with this skill. Execute it strictly when the user invokes the corresponding command.
+    `;
+}

package/adapters/cursor.js

@@ -0,0 +1,16 @@
+/**
+ * Converts a Universal SKILL.md into Cursor / Windsurf / Cline format.
+ * These typically rely on `.cursorrules` or `.windsurfrules` files in the workspace.
+ */
+
+export function buildCursorRules(skillMeta, context) {
+    return `
+# @Rule: ${skillMeta.name}
+Description: ${skillMeta.description}
+
+Rules:
+1. Always follow the universal skill format.
+2. Context injected:
+${context.join('\n')}
+    `;
+}

package/commands/bootstrap.md

@@ -0,0 +1,49 @@
+---
+description: Bootstrap a new project with design system, CI/CD, i18n, SEO, and deploy pipeline
+argument-hint: "<project name or description>"
+---
+
+# /bootstrap — Full Project Setup
+
+Complete project bootstrap: identity lock → security → scaffold → design system → i18n → SEO → AGENTS.md → tests → deploy pipeline.
+
+## Invocation
+
+```
+/bootstrap My new SaaS dashboard
+/bootstrap E-commerce landing page with Tailwind
+```
+
+## Workflow
+
+### Step 1: Gather Requirements
+
+Ask the user for:
+- Project name (kebab-case)
+- Project type (Static / SPA / Workers / Fullstack / Astro)
+- GitHub org and Cloudflare account
+- Domain and languages
+
+### Step 2: Execute Bootstrap
+
+Apply the **cm-project-bootstrap** skill:
+1. Identity Lock (Phase 0)
+2. Security Foundation with **cm-secret-shield** (Phase 0.5)
+3. Project scaffold based on type (Phase 1)
+4. Repository + staging/production branches (Phase 2)
+5. Design system with tokens (Phase 3)
+6. i18n from day 1 (Phase 4)
+7. SEO meta tags (Phase 5)
+8. AGENTS.md generation (Phase 6)
+9. Test infrastructure with **cm-test-gate** (Phase 7)
+10. Deploy pipeline (Phase 8)
+
+### Step 3: Verify
+
+Run `npm run test:gate` to confirm setup.
+
+### Step 4: Suggest Next
+
+- "Ready to plan features? → `/plan`"
+- "Need UI design? → `/ux`"
+- "Ready to deploy? → `/deploy`"

package/commands/build.md

@@ -0,0 +1,48 @@
+---
+description: Build features with TDD discipline — test first, implement, verify through quality gates
+argument-hint: "<feature to build or plan to execute>"
+---
+
+# /build — TDD Build Workflow
+
+Execute implementation with TDD discipline: write tests → implement → verify through 6-gate quality system.
+
+## Invocation
+
+```
+/build Execute the approved authentication plan
+/build Add the payment integration feature
+```
+
+## Workflow
+
+### Step 1: Setup
+
+Check for an existing plan. If none exists, suggest `/plan` first.
+Apply **cm-execution** skill to choose execution mode:
+- Batch execution with checkpoints
+- Subagent-per-task dispatch
+- Parallel for independent problems
+
+### Step 2: Implement with TDD
+
+For each task, apply **cm-tdd** skill:
+1. **RED** — Write a failing test
+2. **GREEN** — Write minimal code to pass
+3. **REFACTOR** — Clean up while tests stay green
+4. Commit after each green cycle
+
+### Step 3: Quality Gate
+
+Apply **cm-quality-gate** skill:
+- Static analysis
+- Blind review (re-read without context)
+- Anti-sycophancy check
+- Security scan
+- Test coverage verification
+- Ship decision
+
+### Step 4: Suggest Next
+
+- "Ready for review? → `/review`"
+- "Ready to deploy? → `/deploy`"

package/commands/content.md

@@ -0,0 +1,48 @@
+---
+description: AI content engine — research, generate, and deploy content across platforms
+argument-hint: "<content topic or niche>"
+---
+
+# /content — AI Content Factory
+
+Full content lifecycle: research → generate → audit → deploy with multi-agent support.
+
+## Invocation
+
+```
+/content Create social media content for developer tools
+/content Write blog posts about AI productivity
+```
+
+## Workflow
+
+### Step 1: Research
+
+Apply **cm-content-factory** skill:
+- Auto-research niche and audience
+- Apply Content Mastery frameworks (StoryBrand, Cialdini, SUCCESs, STEPPS, Hook Model, JTBD)
+- Identify content gaps and opportunities
+
+### Step 2: Generate
+
+- Create content based on the research
+- Apply CRO principles for conversion
+- Multi-format: blog, social, email, video scripts
+
+### Step 3: Audit
+
+- Check for engagement hooks
+- Verify CTA placement
+- Review for brand consistency
+
+### Step 4: Deploy
+
+- Format for target platforms
+- Schedule or publish content
+- Track performance metrics
+
+## Notes
+
+- Config-driven, niche-agnostic
+- Supports multiple content frameworks
+- Self-improving through feedback loops

package/commands/continuity.md

@@ -0,0 +1,60 @@
+---
+description: Read and update working memory — maintain context across sessions via CONTINUITY.md
+argument-hint: "[read|update|init|status]"
+---
+
+# /continuity — Working Memory
+
+Manage working memory to maintain context across AI coding sessions.
+
+## Invocation
+
+```
+/continuity init
+/continuity read
+/continuity update
+/continuity status
+```
+
+## Workflow
+
+### /continuity init
+
+Create the `.cm/` working memory directory:
+```
+.cm/
+├── CONTINUITY.md          # Active goal, task, learnings
+├── config.yaml            # RARV cycle settings
+└── memory/
+    ├── learnings.json     # Error patterns (auto-captured)
+    └── decisions.json     # Architecture decisions
+```
+
+### /continuity read
+
+Apply **cm-continuity** skill:
+- Read CONTINUITY.md at session start
+- Load past learnings and decisions
+- Understand current project state and active goal
+
+### /continuity update
+
+- Update active task status
+- Record any new learnings or mistakes
+- Save architecture decisions
+- Ensure next session has full context
+
+### /continuity status
+
+Show current working memory state:
+- Active goal and task
+- Recent learnings
+- Key decisions
+- Session count
+
+## Notes
+
+- Always read CONTINUITY.md at the start of every session
+- Always update CONTINUITY.md before ending a session
+- Learnings prevent repeating the same mistakes
+- Decisions provide architecture context

package/commands/debug.md

@@ -0,0 +1,51 @@
+---
+description: Systematic debugging — 4-phase root cause process with defense-in-depth verification
+argument-hint: "<bug description or error message>"
+---
+
+# /debug — Systematic Debugging
+
+4-phase systematic debugging: reproduce → isolate → fix → verify with defense-in-depth.
+
+## Invocation
+
+```
+/debug TypeError: Cannot read property 'id' of undefined
+/debug Login page shows blank after OAuth redirect
+```
+
+## Workflow
+
+### Step 1: Reproduce
+
+Apply **cm-debugging** skill:
+1. Understand the error context
+2. Reproduce the issue reliably
+3. Identify the exact conditions
+
+### Step 2: Root Cause Analysis
+
+5-phase investigation:
+1. **Observe** — Read error logs, stack traces
+2. **Hypothesize** — Form 2-3 possible causes
+3. **Test** — Write a test that reproduces the bug
+4. **Isolate** — Narrow down to exact root cause
+5. **Verify** — Confirm the root cause with evidence
+
+### Step 3: Fix with TDD
+
+1. Write a failing test that exposes the bug
+2. Fix the code minimally
+3. Confirm the test passes
+4. Run full test suite to check for regressions
+
+### Step 4: Defense-in-Depth
+
+- Add error handling for similar cases
+- Update documentation if needed
+- Record learning in CONTINUITY.md
+
+### Step 5: Suggest Next
+
+- "Fixed? → `/review` to verify the fix"
+- "Need broader changes? → `/plan`"