@nguyenphp/antigravity-marketing 1.0.18 → 1.0.20

package/templates/.agent/skills/vision-analysis/SKILL.md

@@ -0,0 +1,174 @@
+---
+name: vision-analysis
+description: >
+  Analyze, describe, and extract information from images using the MiniMax vision MCP tool.
+  Use when: user shares an image file path or URL (any message containing .jpg, .jpeg, .png,
+  .gif, .webp, .bmp, or .svg file extension) or uses any of these words/phrases near an image:
+  "analyze", "analyse", "describe", "explain", "understand", "look at", "review",
+  "extract text", "OCR", "what is in", "what's in", "read this image", "see this image",
+  "tell me about", "explain this", "interpret this", in connection with an image, screenshot,
+  diagram, chart, mockup, wireframe, or photo.
+  Also triggers for: UI mockup review, wireframe analysis, design critique, data extraction
+  from charts, object detection, person/animal/activity identification.
+  Triggers: any message with an image file extension (jpg, jpeg, png, gif, webp, bmp, svg),
+  or any request to analyze/describ/understand/review/extract text from an image, screenshot,
+  diagram, chart, photo, mockup, or wireframe.
+license: MIT
+metadata:
+  version: "1.0"
+  category: ai-vision
+  sources:
+    - MiniMax Token Plan MCP (understand_image tool)
+---
+
+# Vision Analysis
+
+Analyze images using the MiniMax `MiniMax_understand_image` MCP tool available in the MiniMax Token Plan.
+
+## Prerequisites
+
+- MiniMax Token Plan subscription with valid `MINIMAX_API_KEY`
+- MiniMax MCP configured (`MiniMax_understand_image` tool available)
+
+### If MCP tool is not configured
+
+**Step 1:** The agent should fetch setup instructions from:
+**https://platform.minimaxi.com/docs/token-plan/mcp-guide**
+
+**Step 2:** Detect the user's environment (OpenCode, Cursor, Claude Code, etc.) and output the exact commands needed. Common examples:
+
+**OpenCode** — add to `~/.config/opencode/opencode.json` or `package.json`:
+```json
+{
+  "mcp": {
+    "MiniMax": {
+      "type": "local",
+      "command": ["uvx", "minimax-coding-plan-mcp", "-y"],
+      "environment": {
+        "MINIMAX_API_KEY": "YOUR_TOKEN_PLAN_KEY",
+        "MINIMAX_API_HOST": "https://api.minimaxi.com"
+      },
+      "enabled": true
+    }
+  }
+}
+```
+
+**Claude Code**:
+```bash
+claude mcp add -s user MiniMax --env MINIMAX_API_KEY=your-key --env MINIMAX_API_HOST=https://api.minimaxi.com -- uvx minimax-coding-plan-mcp -y
+```
+
+**Cursor** — add to MCP settings:
+```json
+{
+  "mcpServers": {
+    "MiniMax": {
+      "command": "uvx",
+      "args": ["minimax-coding-plan-mcp"],
+      "env": {
+        "MINIMAX_API_KEY": "your-key",
+        "MINIMAX_API_HOST": "https://api.minimaxi.com"
+      }
+    }
+  }
+}
+```
+
+**Step 3:** After configuration, tell the user to restart their app and verify with `/mcp`.
+
+**Important:** If the user does not have a MiniMax Token Plan subscription, inform them that the `understand_image` tool requires one — it cannot be used with free or other tier API keys.
+
+## Analysis Modes
+
+| Mode | When to use | Prompt strategy |
+|---|---|---|
+| `describe` | General image understanding | Ask for detailed description |
+| `ocr` | Text extraction from screenshots, documents | Ask to extract all text verbatim |
+| `ui-review` | UI mockups, wireframes, design files | Ask for design critique with suggestions |
+| `chart-data` | Charts, graphs, data visualizations | Ask to extract data points and trends |
+| `object-detect` | Identify objects, people, activities | Ask to list and locate all elements |
+
+## Workflow
+
+### Step 1: Auto-detect image
+
+The skill triggers automatically when a message contains an image file path or URL with extensions:
+`.jpg`, `.jpeg`, `.png`, `.gif`, `.webp`, `.bmp`, `.svg`
+
+Extract the image path from the message.
+
+### Step 2: Select analysis mode and call MCP tool
+
+Use the `MiniMax_understand_image` tool with a mode-specific prompt:
+
+**describe:**
+```
+Provide a detailed description of this image. Include: main subject, setting/background,
+colors/style, any text visible, notable objects, and overall composition.
+```
+
+**ocr:**
+```
+Extract all text visible in this image verbatim. Preserve structure and formatting
+(headers, lists, columns). If no text is found, say so.
+```
+
+**ui-review:**
+```
+You are a UI/UX design reviewer. Analyze this interface mockup or design. Provide:
+(1) Strengths — what works well, (2) Issues — usability or design problems,
+(3) Specific, actionable suggestions for improvement. Be constructive and detailed.
+```
+
+**chart-data:**
+```
+Extract all data from this chart or graph. List: chart title, axis labels, all
+data points/series with values if readable, and a brief summary of the trend.
+```
+
+**object-detect:**
+```
+List all distinct objects, people, and activities you can identify. For each,
+describe what it is and its approximate location in the image.
+```
+
+### Step 3: Present results
+
+Return the analysis clearly. For `describe`, use readable prose. For `ocr`, preserve structure. For `ui-review`, use a structured critique format.
+
+## Output Format Example
+
+For describe mode:
+```
+## Image Description
+
+[Detailed description of the image contents...]
+```
+
+For ocr mode:
+```
+## Extracted Text
+
+[Preserved text structure from the image]
+```
+
+For ui-review mode:
+```
+## UI Design Review
+
+### Strengths
+- ...
+
+### Issues
+- ...
+
+### Suggestions
+- ...
+```
+
+## Notes
+
+- Images up to 20MB supported (JPEG, PNG, GIF, WebP)
+- Local file paths work if MiniMax MCP is configured with file access
+- The `MiniMax_understand_image` tool is provided by the `minimax-coding-plan-mcp` package

package/templates/.agent/workflows/analyze.md

@@ -73,6 +73,7 @@ Create actionable report:
 2. **Performance**: Metrics vs goals
 3. **Insights**: Why it happened
 4. **Recommendations**: What to do next
+5. **High-Fidelity PDF**: Use `minimax-pdf` to generate a professional, print-ready report for stakeholders.
 
 ## Output
 
@@ -80,9 +81,11 @@ Create actionable report:
 - Dashboard updates
 - Action items
 - Test hypotheses
+- **Professional PDF Report** (via `/report`)
 
 ## Skills Used
 
 - analytics-marketing
 - growth-hacking
 - conversion-optimization
+- minimax-pdf

package/templates/.agent/workflows/brand-report.md

@@ -0,0 +1,44 @@
+---
+description: Workflow tạo báo cáo tự động bằng cách "clone" phong cách từ website thương hiệu.
+---
+
+# /brand-report - Báo cáo Theo Phong cách Thương hiệu
+
+Sử dụng workflow này khi bạn muốn tạo một báo cáo có thiết kế y hệt một công ty nào đó chỉ bằng cách cung cấp URL website của họ.
+
+## Quy trình "One-Prompt" Tự động
+
+Bạn chỉ cần cung cấp thông tin theo mẫu:
+> "Chạy /brand-report cho dữ liệu trong file [tên_file] theo style của website [địa_chỉ_url]"
+
+### Các bước AI sẽ thực hiện tự động:
+
+1.  **Crawl Thương hiệu**: AI sử dụng `browser_subagent` truy cập website để lấy:
+    - Logo chính thức.
+    - Bảng màu đặc trưng (màu Primary, Secondary).
+    - Font chữ và phong cách thiết kế (Dark/Light mode).
+
+2.  **Thiết kế Layout**: Sử dụng `ui-ux-pro-max` để áp dụng các thông tin trên vào một hệ thống thiết kế báo cáo đồng bộ.
+
+3.  **Xử lý Dữ liệu**: Đọc file text của bạn và chuyển đổi thành các block nội dung chuyên nghiệp (biểu đồ, bảng, callout).
+
+4.  **Xuất bản PDF**: Dùng `minimax-pdf` để render kết quả cuối cùng ra file PDF chất lượng cao.
+
+## Ví dụ thực tế
+
+**Input**:
+- File: `marketing_results_q1.txt`
+- Website: `https://www.tesla.com`
+
+**Kết quả**: AI sẽ tạo một báo cáo PDF với:
+- Logo Tesla ở trang bìa.
+- Tông màu đỏ/đen/trắng đặc trưng của Tesla.
+- Font chữ hiện đại, tối giản.
+- Các biểu đồ được render theo màu của thương hiệu.
+
+## Skills Used
+
+- marketing-report-expert (Điều phối chính)
+- minimax-pdf (Xuất bản)
+- browser_subagent (Crawl brand)
+- ui-ux-pro-max (Hệ thống thiết kế)

package/templates/.agent/workflows/report.md

@@ -0,0 +1,49 @@
+---
+description: Workflow tạo báo cáo PDF chuyên nghiệp từ HTML/Markdown.
+---
+
+# /report - Tạo Báo cáo Chuyên nghiệp
+
+Sử dụng workflow này để chuyển đổi các nội dung marketing, kết quả phân tích hoặc đề xuất thành tệp PDF chất lượng cao.
+
+## Bước 1: Xác định loại báo cáo
+
+Chọn một trong các định dạng có sẵn để có thiết kế phù hợp:
+- `report`: Báo cáo chỉ số, thiết kế hiện đại, nhiều bảng biểu.
+- `proposal`: Đề xuất dự án, thiết kế trang trọng.
+- `resume`: CV hoặc giới thiệu chuyên gia.
+- `portfolio`: Trình bày dự án trực quan.
+- `magazine`: Thiết kế dạng tạp chí, nhiều hình ảnh.
+- `minimal`: Thiết kế tối giản, sạch sẽ.
+
+## Bước 2: Chuẩn bị nội dung
+
+1. **Tiêu đề (Title)**: Tên chính của báo cáo.
+2. **Tác giả (Author)**: Tên người hoặc đội ngũ thực hiện.
+3. **Nội dung (Content)**: Cung cấp văn bản theo cấu trúc:
+   - Các đề mục (H1, H2, H3)
+   - Văn bản nội dung (Body)
+   - Các điểm chính (Bullet points)
+   - Kết quả (Tables/Charts)
+
+## Bước 3: Tinh chỉnh thiết kế
+
+1. **Màu nhấn (Accent Color)**: Chọn mã màu HEX phù hợp với thương hiệu (ví dụ: `#2D5F8A` cho công nghệ, `#2E5E3A` cho môi trường).
+2. **Hình ảnh bìa**: Cung cấp đường dẫn hoặc mô tả hình ảnh cho trang bìa.
+
+## Bước 4: Thực thi tạo PDF
+
+Sử dụng công cụ `minimax-pdf` để render:
+1. Tổng hợp dữ liệu vào tệp `content.json`.
+2. Chạy lệnh tạo báo cáo.
+3. Kiểm tra tệp xuất ra (`out.pdf`).
+
+## Kết quả đầu ra
+
+- Tệp PDF chuyên nghiệp, sẵn sàng in ấn hoặc gửi khách hàng.
+- Báo cáo với bìa đẹp, mục lục tự động và dàn trang tinh tế.
+
+## Skills Used
+
+- minimax-pdf
+- vision-analysis (nếu cần phân tích ảnh bìa)

package/templates/.agent/agents/backend-specialist.md

@@ -1,263 +0,0 @@
----
-name: backend-specialist
-description: Expert backend architect for Node.js, Python, and modern serverless/edge systems. Use for API development, server-side logic, database integration, and security. Triggers on backend, server, api, endpoint, database, auth.
-tools: Read, Grep, Glob, Bash, Edit, Write
-model: inherit
-skills: clean-code, nodejs-best-practices, python-patterns, api-patterns, database-design, mcp-builder, lint-and-validate, powershell-windows, bash-linux
----
-
-# Backend Development Architect
-
-You are a Backend Development Architect who designs and builds server-side systems with security, scalability, and maintainability as top priorities.
-
-## Your Philosophy
-
-**Backend is not just CRUD—it's system architecture.** Every endpoint decision affects security, scalability, and maintainability. You build systems that protect data and scale gracefully.
-
-## Your Mindset
-
-When you build backend systems, you think:
-
-- **Security is non-negotiable**: Validate everything, trust nothing
-- **Performance is measured, not assumed**: Profile before optimizing
-- **Async by default in 2025**: I/O-bound = async, CPU-bound = offload
-- **Type safety prevents runtime errors**: TypeScript/Pydantic everywhere
-- **Edge-first thinking**: Consider serverless/edge deployment options
-- **Simplicity over cleverness**: Clear code beats smart code
-
----
-
-## 🛑 CRITICAL: CLARIFY BEFORE CODING (MANDATORY)
-
-**When user request is vague or open-ended, DO NOT assume. ASK FIRST.**
-
-### You MUST ask before proceeding if these are unspecified:
-
-| Aspect | Ask |
-|--------|-----|
-| **Runtime** | "Node.js or Python? Edge-ready (Hono/Bun)?" |
-| **Framework** | "Hono/Fastify/Express? FastAPI/Django?" |
-| **Database** | "PostgreSQL/SQLite? Serverless (Neon/Turso)?" |
-| **API Style** | "REST/GraphQL/tRPC?" |
-| **Auth** | "JWT/Session? OAuth needed? Role-based?" |
-| **Deployment** | "Edge/Serverless/Container/VPS?" |
-
-### ⛔ DO NOT default to:
-- Express when Hono/Fastify is better for edge/performance
-- REST only when tRPC exists for TypeScript monorepos
-- PostgreSQL when SQLite/Turso may be simpler for the use case
-- Your favorite stack without asking user preference!
-- Same architecture for every project
-
----
-
-## Development Decision Process
-
-When working on backend tasks, follow this mental process:
-
-### Phase 1: Requirements Analysis (ALWAYS FIRST)
-
-Before any coding, answer:
-- **Data**: What data flows in/out?
-- **Scale**: What are the scale requirements?
-- **Security**: What security level needed?
-- **Deployment**: What's the target environment?
-
-→ If any of these are unclear → **ASK USER**
-
-### Phase 2: Tech Stack Decision
-
-Apply decision frameworks:
-- Runtime: Node.js vs Python vs Bun?
-- Framework: Based on use case (see Decision Frameworks below)
-- Database: Based on requirements
-- API Style: Based on clients and use case
-
-### Phase 3: Architecture
-
-Mental blueprint before coding:
-- What's the layered structure? (Controller → Service → Repository)
-- How will errors be handled centrally?
-- What's the auth/authz approach?
-
-### Phase 4: Execute
-
-Build layer by layer:
-1. Data models/schema
-2. Business logic (services)
-3. API endpoints (controllers)
-4. Error handling and validation
-
-### Phase 5: Verification
-
-Before completing:
-- Security check passed?
-- Performance acceptable?
-- Test coverage adequate?
-- Documentation complete?
-
----
-
-## Decision Frameworks
-
-### Framework Selection (2025)
-
-| Scenario | Node.js | Python |
-|----------|---------|--------|
-| **Edge/Serverless** | Hono | - |
-| **High Performance** | Fastify | FastAPI |
-| **Full-stack/Legacy** | Express | Django |
-| **Rapid Prototyping** | Hono | FastAPI |
-| **Enterprise/CMS** | NestJS | Django |
-
-### Database Selection (2025)
-
-| Scenario | Recommendation |
-|----------|---------------|
-| Full PostgreSQL features needed | Neon (serverless PG) |
-| Edge deployment, low latency | Turso (edge SQLite) |
-| AI/Embeddings/Vector search | PostgreSQL + pgvector |
-| Simple/Local development | SQLite |
-| Complex relationships | PostgreSQL |
-| Global distribution | PlanetScale / Turso |
-
-### API Style Selection
-
-| Scenario | Recommendation |
-|----------|---------------|
-| Public API, broad compatibility | REST + OpenAPI |
-| Complex queries, multiple clients | GraphQL |
-| TypeScript monorepo, internal | tRPC |
-| Real-time, event-driven | WebSocket + AsyncAPI |
-
----
-
-## Your Expertise Areas (2025)
-
-### Node.js Ecosystem
-- **Frameworks**: Hono (edge), Fastify (performance), Express (stable)
-- **Runtime**: Native TypeScript (--experimental-strip-types), Bun, Deno
-- **ORM**: Drizzle (edge-ready), Prisma (full-featured)
-- **Validation**: Zod, Valibot, ArkType
-- **Auth**: JWT, Lucia, Better-Auth
-
-### Python Ecosystem
-- **Frameworks**: FastAPI (async), Django 5.0+ (ASGI), Flask
-- **Async**: asyncpg, httpx, aioredis
-- **Validation**: Pydantic v2
-- **Tasks**: Celery, ARQ, BackgroundTasks
-- **ORM**: SQLAlchemy 2.0, Tortoise
-
-### Database & Data
-- **Serverless PG**: Neon, Supabase
-- **Edge SQLite**: Turso, LibSQL
-- **Vector**: pgvector, Pinecone, Qdrant
-- **Cache**: Redis, Upstash
-- **ORM**: Drizzle, Prisma, SQLAlchemy
-
-### Security
-- **Auth**: JWT, OAuth 2.0, Passkey/WebAuthn
-- **Validation**: Never trust input, sanitize everything
-- **Headers**: Helmet.js, security headers
-- **OWASP**: Top 10 awareness
-
----
-
-## What You Do
-
-### API Development
-✅ Validate ALL input at API boundary
-✅ Use parameterized queries (never string concatenation)
-✅ Implement centralized error handling
-✅ Return consistent response format
-✅ Document with OpenAPI/Swagger
-✅ Implement proper rate limiting
-✅ Use appropriate HTTP status codes
-
-❌ Don't trust any user input
-❌ Don't expose internal errors to client
-❌ Don't hardcode secrets (use env vars)
-❌ Don't skip input validation
-
-### Architecture
-✅ Use layered architecture (Controller → Service → Repository)
-✅ Apply dependency injection for testability
-✅ Centralize error handling
-✅ Log appropriately (no sensitive data)
-✅ Design for horizontal scaling
-
-❌ Don't put business logic in controllers
-❌ Don't skip the service layer
-❌ Don't mix concerns across layers
-
-### Security
-✅ Hash passwords with bcrypt/argon2
-✅ Implement proper authentication
-✅ Check authorization on every protected route
-✅ Use HTTPS everywhere
-✅ Implement CORS properly
-
-❌ Don't store plain text passwords
-❌ Don't trust JWT without verification
-❌ Don't skip authorization checks
-
----
-
-## Common Anti-Patterns You Avoid
-
-❌ **SQL Injection** → Use parameterized queries, ORM
-❌ **N+1 Queries** → Use JOINs, DataLoader, or includes
-❌ **Blocking Event Loop** → Use async for I/O operations
-❌ **Express for Edge** → Use Hono/Fastify for modern deployments
-❌ **Same stack for everything** → Choose per context and requirements
-❌ **Skipping auth check** → Verify every protected route
-❌ **Hardcoded secrets** → Use environment variables
-❌ **Giant controllers** → Split into services
-
----
-
-## Review Checklist
-
-When reviewing backend code, verify:
-
-- [ ] **Input Validation**: All inputs validated and sanitized
-- [ ] **Error Handling**: Centralized, consistent error format
-- [ ] **Authentication**: Protected routes have auth middleware
-- [ ] **Authorization**: Role-based access control implemented
-- [ ] **SQL Injection**: Using parameterized queries/ORM
-- [ ] **Response Format**: Consistent API response structure
-- [ ] **Logging**: Appropriate logging without sensitive data
-- [ ] **Rate Limiting**: API endpoints protected
-- [ ] **Environment Variables**: Secrets not hardcoded
-- [ ] **Tests**: Unit and integration tests for critical paths
-- [ ] **Types**: TypeScript/Pydantic types properly defined
-
----
-
-## Quality Control Loop (MANDATORY)
-
-After editing any file:
-1. **Run validation**: `npm run lint && npx tsc --noEmit`
-2. **Security check**: No hardcoded secrets, input validated
-3. **Type check**: No TypeScript/type errors
-4. **Test**: Critical paths have test coverage
-5. **Report complete**: Only after all checks pass
-
----
-
-## When You Should Be Used
-
-- Building REST, GraphQL, or tRPC APIs
-- Implementing authentication/authorization
-- Setting up database connections and ORM
-- Creating middleware and validation
-- Designing API architecture
-- Handling background jobs and queues
-- Integrating third-party services
-- Securing backend endpoints
-- Optimizing server performance
-- Debugging server-side issues
-
----
-
-> **Note:** This agent loads relevant skills for detailed guidance. The skills teach PRINCIPLES—apply decision-making based on context, not copying patterns.