@nguyenphp/antigravity-marketing 1.0.16 → 1.0.19

package/templates/.agent/skills/lint-and-validate/scripts/lint_runner.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""
+Lint Runner - Unified linting and type checking
+Runs appropriate linters based on project type.
+
+Usage:
+    python lint_runner.py <project_path>
+
+Supports:
+    - Node.js: npm run lint, npx tsc --noEmit
+    - Python: ruff check, mypy
+"""
+
+import subprocess
+import sys
+import json
+from pathlib import Path
+from datetime import datetime
+
+# Fix Windows console encoding
+try:
+    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+except:
+    pass
+
+
+def detect_project_type(project_path: Path) -> dict:
+    """Detect project type and available linters."""
+    result = {
+        "type": "unknown",
+        "linters": []
+    }
+    
+    # Node.js project
+    package_json = project_path / "package.json"
+    if package_json.exists():
+        result["type"] = "node"
+        try:
+            pkg = json.loads(package_json.read_text(encoding='utf-8'))
+            scripts = pkg.get("scripts", {})
+            deps = {**pkg.get("dependencies", {}), **pkg.get("devDependencies", {})}
+            
+            # Check for lint script
+            if "lint" in scripts:
+                result["linters"].append({"name": "npm lint", "cmd": ["npm", "run", "lint"]})
+            elif "eslint" in deps:
+                result["linters"].append({"name": "eslint", "cmd": ["npx", "eslint", "."]})
+            
+            # Check for TypeScript
+            if "typescript" in deps or (project_path / "tsconfig.json").exists():
+                result["linters"].append({"name": "tsc", "cmd": ["npx", "tsc", "--noEmit"]})
+                
+        except:
+            pass
+    
+    # Python project
+    if (project_path / "pyproject.toml").exists() or (project_path / "requirements.txt").exists():
+        result["type"] = "python"
+        
+        # Check for ruff
+        result["linters"].append({"name": "ruff", "cmd": ["ruff", "check", "."]})
+        
+        # Check for mypy
+        if (project_path / "mypy.ini").exists() or (project_path / "pyproject.toml").exists():
+            result["linters"].append({"name": "mypy", "cmd": ["mypy", "."]})
+    
+    return result
+
+
+def run_linter(linter: dict, cwd: Path) -> dict:
+    """Run a single linter and return results."""
+    result = {
+        "name": linter["name"],
+        "passed": False,
+        "output": "",
+        "error": ""
+    }
+    
+    try:
+        proc = subprocess.run(
+            linter["cmd"],
+            cwd=str(cwd),
+            capture_output=True,
+            text=True,
+            encoding='utf-8',
+            errors='replace',
+            timeout=120
+        )
+        
+        result["output"] = proc.stdout[:2000] if proc.stdout else ""
+        result["error"] = proc.stderr[:500] if proc.stderr else ""
+        result["passed"] = proc.returncode == 0
+        
+    except FileNotFoundError:
+        result["error"] = f"Command not found: {linter['cmd'][0]}"
+    except subprocess.TimeoutExpired:
+        result["error"] = "Timeout after 120s"
+    except Exception as e:
+        result["error"] = str(e)
+    
+    return result
+
+
+def main():
+    project_path = Path(sys.argv[1] if len(sys.argv) > 1 else ".").resolve()
+    
+    print(f"\n{'='*60}")
+    print(f"[LINT RUNNER] Unified Linting")
+    print(f"{'='*60}")
+    print(f"Project: {project_path}")
+    print(f"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    
+    # Detect project type
+    project_info = detect_project_type(project_path)
+    print(f"Type: {project_info['type']}")
+    print(f"Linters: {len(project_info['linters'])}")
+    print("-"*60)
+    
+    if not project_info["linters"]:
+        print("No linters found for this project type.")
+        output = {
+            "script": "lint_runner",
+            "project": str(project_path),
+            "type": project_info["type"],
+            "checks": [],
+            "passed": True,
+            "message": "No linters configured"
+        }
+        print(json.dumps(output, indent=2))
+        sys.exit(0)
+    
+    # Run each linter
+    results = []
+    all_passed = True
+    
+    for linter in project_info["linters"]:
+        print(f"\nRunning: {linter['name']}...")
+        result = run_linter(linter, project_path)
+        results.append(result)
+        
+        if result["passed"]:
+            print(f"  [PASS] {linter['name']}")
+        else:
+            print(f"  [FAIL] {linter['name']}")
+            if result["error"]:
+                print(f"  Error: {result['error'][:200]}")
+            all_passed = False
+    
+    # Summary
+    print("\n" + "="*60)
+    print("SUMMARY")
+    print("="*60)
+    
+    for r in results:
+        icon = "[PASS]" if r["passed"] else "[FAIL]"
+        print(f"{icon} {r['name']}")
+    
+    output = {
+        "script": "lint_runner",
+        "project": str(project_path),
+        "type": project_info["type"],
+        "checks": results,
+        "passed": all_passed
+    }
+    
+    print("\n" + json.dumps(output, indent=2))
+    
+    sys.exit(0 if all_passed else 1)
+
+
+if __name__ == "__main__":
+    main()

package/templates/.agent/skills/lint-and-validate/scripts/type_coverage.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+"""
+Type Coverage Checker - Measures TypeScript/Python type coverage.
+Identifies untyped functions, any usage, and type safety issues.
+"""
+import sys
+import re
+import subprocess
+from pathlib import Path
+
+# Fix Windows console encoding for Unicode output
+try:
+    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+    sys.stderr.reconfigure(encoding='utf-8', errors='replace')
+except AttributeError:
+    pass  # Python < 3.7
+
+def check_typescript_coverage(project_path: Path) -> dict:
+    """Check TypeScript type coverage."""
+    issues = []
+    passed = []
+    stats = {'any_count': 0, 'untyped_functions': 0, 'total_functions': 0}
+    
+    ts_files = list(project_path.rglob("*.ts")) + list(project_path.rglob("*.tsx"))
+    ts_files = [f for f in ts_files if 'node_modules' not in str(f) and '.d.ts' not in str(f)]
+    
+    if not ts_files:
+        return {'type': 'typescript', 'files': 0, 'passed': [], 'issues': ["[!] No TypeScript files found"], 'stats': stats}
+    
+    for file_path in ts_files[:30]:  # Limit
+        try:
+            content = file_path.read_text(encoding='utf-8', errors='ignore')
+            
+            # Count 'any' usage
+            any_matches = re.findall(r':\s*any\b', content)
+            stats['any_count'] += len(any_matches)
+            
+            # Find functions without return types
+            # function name(params) { - no return type
+            untyped = re.findall(r'function\s+\w+\s*\([^)]*\)\s*{', content)
+            # Arrow functions without types: const fn = (x) => or (x) =>
+            untyped += re.findall(r'=\s*\([^:)]*\)\s*=>', content)
+            stats['untyped_functions'] += len(untyped)
+            
+            # Count typed functions
+            typed = re.findall(r'function\s+\w+\s*\([^)]*\)\s*:\s*\w+', content)
+            typed += re.findall(r':\s*\([^)]*\)\s*=>\s*\w+', content)
+            stats['total_functions'] += len(typed) + len(untyped)
+            
+        except Exception:
+            continue
+    
+    # Analyze results
+    if stats['any_count'] == 0:
+        passed.append("[OK] No 'any' types found")
+    elif stats['any_count'] <= 5:
+        issues.append(f"[!] {stats['any_count']} 'any' types found (acceptable)")
+    else:
+        issues.append(f"[X] {stats['any_count']} 'any' types found (too many)")
+    
+    if stats['total_functions'] > 0:
+        typed_ratio = (stats['total_functions'] - stats['untyped_functions']) / stats['total_functions'] * 100
+        if typed_ratio >= 80:
+            passed.append(f"[OK] Type coverage: {typed_ratio:.0f}%")
+        elif typed_ratio >= 50:
+            issues.append(f"[!] Type coverage: {typed_ratio:.0f}% (improve)")
+        else:
+            issues.append(f"[X] Type coverage: {typed_ratio:.0f}% (too low)")
+    
+    passed.append(f"[OK] Analyzed {len(ts_files)} TypeScript files")
+    
+    return {'type': 'typescript', 'files': len(ts_files), 'passed': passed, 'issues': issues, 'stats': stats}
+
+def check_python_coverage(project_path: Path) -> dict:
+    """Check Python type hints coverage."""
+    issues = []
+    passed = []
+    stats = {'untyped_functions': 0, 'typed_functions': 0, 'any_count': 0}
+    
+    py_files = list(project_path.rglob("*.py"))
+    py_files = [f for f in py_files if not any(x in str(f) for x in ['venv', '__pycache__', '.git', 'node_modules'])]
+    
+    if not py_files:
+        return {'type': 'python', 'files': 0, 'passed': [], 'issues': ["[!] No Python files found"], 'stats': stats}
+    
+    for file_path in py_files[:30]:  # Limit
+        try:
+            content = file_path.read_text(encoding='utf-8', errors='ignore')
+            
+            # Count Any usage
+            any_matches = re.findall(r':\s*Any\b', content)
+            stats['any_count'] += len(any_matches)
+            
+            # Find functions with type hints
+            typed_funcs = re.findall(r'def\s+\w+\s*\([^)]*:[^)]+\)', content)
+            typed_funcs += re.findall(r'def\s+\w+\s*\([^)]*\)\s*->', content)
+            stats['typed_functions'] += len(typed_funcs)
+            
+            # Find functions without type hints
+            all_funcs = re.findall(r'def\s+\w+\s*\(', content)
+            stats['untyped_functions'] += len(all_funcs) - len(typed_funcs)
+            
+        except Exception:
+            continue
+    
+    total = stats['typed_functions'] + stats['untyped_functions']
+    
+    if total > 0:
+        typed_ratio = stats['typed_functions'] / total * 100
+        if typed_ratio >= 70:
+            passed.append(f"[OK] Type hints coverage: {typed_ratio:.0f}%")
+        elif typed_ratio >= 40:
+            issues.append(f"[!] Type hints coverage: {typed_ratio:.0f}%")
+        else:
+            issues.append(f"[X] Type hints coverage: {typed_ratio:.0f}% (add type hints)")
+    
+    if stats['any_count'] == 0:
+        passed.append("[OK] No 'Any' types found")
+    elif stats['any_count'] <= 3:
+        issues.append(f"[!] {stats['any_count']} 'Any' types found")
+    else:
+        issues.append(f"[X] {stats['any_count']} 'Any' types found")
+    
+    passed.append(f"[OK] Analyzed {len(py_files)} Python files")
+    
+    return {'type': 'python', 'files': len(py_files), 'passed': passed, 'issues': issues, 'stats': stats}
+
+def main():
+    target = sys.argv[1] if len(sys.argv) > 1 else "."
+    project_path = Path(target)
+    
+    print("\n" + "=" * 60)
+    print("  TYPE COVERAGE CHECKER")
+    print("=" * 60 + "\n")
+    
+    results = []
+    
+    # Check TypeScript
+    ts_result = check_typescript_coverage(project_path)
+    if ts_result['files'] > 0:
+        results.append(ts_result)
+    
+    # Check Python
+    py_result = check_python_coverage(project_path)
+    if py_result['files'] > 0:
+        results.append(py_result)
+    
+    if not results:
+        print("[!] No TypeScript or Python files found.")
+        sys.exit(0)
+    
+    # Print results
+    critical_issues = 0
+    for result in results:
+        print(f"\n[{result['type'].upper()}]")
+        print("-" * 40)
+        for item in result['passed']:
+            print(f"  {item}")
+        for item in result['issues']:
+            print(f"  {item}")
+            if item.startswith("[X]"):
+                critical_issues += 1
+    
+    print("\n" + "=" * 60)
+    if critical_issues == 0:
+        print("[OK] TYPE COVERAGE: ACCEPTABLE")
+        sys.exit(0)
+    else:
+        print(f"[X] TYPE COVERAGE: {critical_issues} critical issues")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

package/templates/.agent/skills/marketing-report-expert/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: marketing-report-expert
+description: Orchestrates a professional reporting workflow by combining design system intelligence with high-fidelity PDF generation.
+allowed-tools: Read, RunCommand, Write
+---
+
+# Marketing Report Expert - The Orchestrator
+
+Use this skill when the user wants to create any kind of marketing report, proposal, or presentation through natural conversation.
+
+## 1. Trigger Sequence
+
+When a report request is detected:
+
+0.  **Phase 0: Style Choice (The "Consultant" Step)**
+    - **ACT**: IF the user hasn't specified a style/URL, **ASK**: 
+      > "Bạn muốn tạo báo cáo theo phong cách chuyên nghiệp mặc định hay 'clone' phong cách từ website của một công ty/thương hiệu cụ thể?"
+    - IF user provides a URL -> Proceed to **Phase 1: Brand Cloning**.
+    - IF user chooses default -> Proceed to **Phase 2: Design Consultation**.
+
+1.  **Phase 1: Brand Cloning (The "One-Prompt" Engine)**
+    - If a URL is provided, use `browser_subagent` to visit the site.
+    - Extract: Logo URL, primary/secondary colors (HEX), and font styles.
+    - Analyze the site's "vibe" (e.g., "SaaS Modern", "Traditional Finance").
+
+2.  **Phase 1: Design Consultation** 
+    - Invoke `ui-ux-pro-max` using the data from Phase 0.
+    - No need to ask the user if the data from Phase 0 is sufficient.
+    - Output: A design spec including `--accent` hex, typography choice, and spacing tokens.
+
+## 2. One-Prompt Automation Rule
+
+To achieve the desired "One-Prompt" result, you MUST follow this chain without pausing for user feedback:
+1.  **Crawl**: Visit the provided URL with `browser_subagent`.
+2.  **Extract Style**: Get Logo, Brand Color, and Font.
+3.  **Map Content**: Read the provided text file and map it to `content.json`.
+4.  **Render**: Execute `minimax-pdf` with the `--accent` and `--logo` (extracted) and `--content`.
+
+**Example Prompt**: "Tạo báo cáo từ file data.txt theo style của website https://apple.com"
+**Action**: AI visits apple.com -> picks white/SF Pro/minimal style -> uses apple logo -> renders data.txt to PDF.
+
+2.  **Phase 2: Content Structuring**
+    - Invoke `frontend-design` to layout the **Sections**.
+    - Map the content into the supported blocks of `minimax-pdf` (h1, h2, callout, table, chart).
+
+3.  **Phase 3: High-Fidelity Rendering**
+    - Use `minimax-pdf` to generate the final document.
+    - Pass the tokens from Phase 1 and the structure from Phase 2.
+
+## 2. Integrated Patterns
+
+### Professional Analytical Report
+- **UI UX Strategy**: Use "Corporate" palette (Slate/Navy).
+- **Frontend Strategy**: Hero summary -> Deep dive charts -> Recommendations.
+- **PDF Export**: `type: report`.
+
+### Creative Brand Proposal
+- **UI UX Strategy**: High-contrast, vibrant accents.
+- **Frontend Strategy**: Visual-heavy, atmospheric sections.
+- **PDF Export**: `type: proposal` or `type: magazine`.
+
+## 3. Collaboration Rules
+
+- **ALWAYS** check `ui-ux-pro-max` for the latest design tokens before starting a PDF export.
+- **ALWAYS** suggest a "Dry run" or "Preview" of the design before the final merge.
+- If the document is for a specific industry, use the `frontend-design` color psychology guide to pick the accent.
+
+---
+
+> **Mission**: Turn raw data and ideas into a premium, board-ready document without the user needing to manually style anything.

package/templates/.agent/skills/mcp-builder/SKILL.md

@@ -0,0 +1,176 @@
+---
+name: mcp-builder
+description: MCP (Model Context Protocol) server building principles. Tool design, resource patterns, best practices.
+allowed-tools: Read, Write, Edit, Glob, Grep
+---
+
+# MCP Builder
+
+> Principles for building MCP servers.
+
+---
+
+## 1. MCP Overview
+
+### What is MCP?
+
+Model Context Protocol - standard for connecting AI systems with external tools and data sources.
+
+### Core Concepts
+
+| Concept | Purpose |
+|---------|---------|
+| **Tools** | Functions AI can call |
+| **Resources** | Data AI can read |
+| **Prompts** | Pre-defined prompt templates |
+
+---
+
+## 2. Server Architecture
+
+### Project Structure
+
+```
+my-mcp-server/
+├── src/
+│   └── index.ts      # Main entry
+├── package.json
+└── tsconfig.json
+```
+
+### Transport Types
+
+| Type | Use |
+|------|-----|
+| **Stdio** | Local, CLI-based |
+| **SSE** | Web-based, streaming |
+| **WebSocket** | Real-time, bidirectional |
+
+---
+
+## 3. Tool Design Principles
+
+### Good Tool Design
+
+| Principle | Description |
+|-----------|-------------|
+| Clear name | Action-oriented (get_weather, create_user) |
+| Single purpose | One thing well |
+| Validated input | Schema with types and descriptions |
+| Structured output | Predictable response format |
+
+### Input Schema Design
+
+| Field | Required? |
+|-------|-----------|
+| Type | Yes - object |
+| Properties | Define each param |
+| Required | List mandatory params |
+| Description | Human-readable |
+
+---
+
+## 4. Resource Patterns
+
+### Resource Types
+
+| Type | Use |
+|------|-----|
+| Static | Fixed data (config, docs) |
+| Dynamic | Generated on request |
+| Template | URI with parameters |
+
+### URI Patterns
+
+| Pattern | Example |
+|---------|---------|
+| Fixed | `docs://readme` |
+| Parameterized | `users://{userId}` |
+| Collection | `files://project/*` |
+
+---
+
+## 5. Error Handling
+
+### Error Types
+
+| Situation | Response |
+|-----------|----------|
+| Invalid params | Validation error message |
+| Not found | Clear "not found" |
+| Server error | Generic error, log details |
+
+### Best Practices
+
+- Return structured errors
+- Don't expose internal details
+- Log for debugging
+- Provide actionable messages
+
+---
+
+## 6. Multimodal Handling
+
+### Supported Types
+
+| Type | Encoding |
+|------|----------|
+| Text | Plain text |
+| Images | Base64 + MIME type |
+| Files | Base64 + MIME type |
+
+---
+
+## 7. Security Principles
+
+### Input Validation
+
+- Validate all tool inputs
+- Sanitize user-provided data
+- Limit resource access
+
+### API Keys
+
+- Use environment variables
+- Don't log secrets
+- Validate permissions
+
+---
+
+## 8. Configuration
+
+### Claude Desktop Config
+
+| Field | Purpose |
+|-------|---------|
+| command | Executable to run |
+| args | Command arguments |
+| env | Environment variables |
+
+---
+
+## 9. Testing
+
+### Test Categories
+
+| Type | Focus |
+|------|-------|
+| Unit | Tool logic |
+| Integration | Full server |
+| Contract | Schema validation |
+
+---
+
+## 10. Best Practices Checklist
+
+- [ ] Clear, action-oriented tool names
+- [ ] Complete input schemas with descriptions
+- [ ] Structured JSON output
+- [ ] Error handling for all cases
+- [ ] Input validation
+- [ ] Environment-based configuration
+- [ ] Logging for debugging
+
+---
+
+> **Remember:** MCP tools should be simple, focused, and well-documented. The AI relies on descriptions to use them correctly.

package/templates/.agent/skills/minimax-docx/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MiniMaxAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.