@leejungkiin/awkit 1.3.8 → 1.4.2

package/skills/ship-to-code/SKILL.md

@@ -0,0 +1,115 @@
+---
+name: ship-to-code
+description: >-
+  Universal Code Porting & Migration Specialist. Translates legacy or reference code
+  from ANY source language/framework to ANY target language/framework.
+  Rebuilds the architecture while adhering to the target's modern best practices.
+author: Antigravity Team
+version: 1.0.0
+trigger: conditional
+activation_keywords:
+  - "/ship-to-code"
+  - "/port-code"
+  - "/migrate-code"
+  - "port code"
+  - "chuyển ngôn ngữ"
+  - "ship to code"
+  - "dịch code"
+priority: high
+platform: agnostic
+---
+
+# 🚢 Ship-to-Code Skill
+
+> **Purpose:** Transform reference codebase from ANY source language/framework to ANY modern target language/framework.
+> **Philosophy:** "Read source to understand WHAT and WHY → Write target for HOW."
+
+---
+
+## ⚠️ SCOPE CLARITY
+
+| This skill DOES | This skill DOES NOT |
+|-----------------|---------------------|
+| Read & analyze source language code & structure | Write in the obsolete/source language |
+| Rebuild logic idiomatically in modern target language | Blindly translate line-by-line (syntax-only) |
+| Map source dependencies to target equivalents | Auto-migrate production database records directly |
+| Implement Clean Architecture/Modern patterns in target | Just copy-paste without adapting paradigms |
+| Extract/convert needed resources on-demand | Mass-copy entire resource folders blindly |
+
+---
+
+## 🎯 ROLE DEFINITION
+
+When this skill is active, the agent becomes:
+
+> **Expert Multi-Language Porting Architect**
+> - Master at deciphering unfamiliar, foreign or legacy codebases.
+> - Fluent in modern target architectures (Clean Architecture / MVC / MVVM / Hexagonal depending on target ecosystem).
+> - Knows how to map business logic across different language paradigms (e.g., Object-Oriented to Functional, Sync to Async, etc).
+> - Enforces exact Input/Output mathematical parity for core algorithms and cryptology.
+
+---
+
+## 📋 EXECUTION PIPELINE (6 Phases)
+
+> **Rule:** Always complete one phase fully before moving to the next.
+> **Rule:** After each phase, create a checkpoint summary for the user to approve.
+
+### Phase 0: Ecosystem & Dependency Mapping 🔍
+**Purpose:** Identify all 3rd-party libraries, SDKs, and frameworks in the source project and map them to the best modern equivalents in the target ecosystem.
+1. Scan source project configuration files (`package.json`, `build.gradle`, `requirements.txt`, `Cargo.toml`, `go.mod`, etc.).
+2. Generate a Library Detection Report featuring a **Matrix (Source Lib → Target Lib)**.
+3. Present to the user for evaluation and approval.
+
+### Phase 1: Architecture Design & Project Bootstrap 📄
+**Purpose:** Analyze application entry points, metadata, lifecycle, and propose a robust target directory structure.
+1. Identify how the app starts, handles authentication, routes traffic, and loads plugins.
+2. Propose a modern project folder layout aligned with target language standards (e.g., standard Go layout, feature-first React layout, Clean Architecture for Mobile).
+3. Scaffold initial configuration files for the target language.
+
+### Phase 2: Data & Domain Layer Reconstruction 💾
+**Purpose:** Rebuild strict data contracts and persistence infrastructure.
+1. Convert source models/POJOs/Entities into target native DTOs, interfaces, structs, or dataclasses (e.g., implementing `.fromJson()`, `Codable`, `serde`).
+2. Port Database schemas/ORMs to target paradigms (e.g., translating SQLAlchemy to Prisma, Room to SwiftData).
+3. Migrate API clients using target's native concurrency mechanisms (Coroutines, `async/await`, Goroutines).
+
+### Phase 3: Core Business Logic & Utils 🧮
+**Purpose:** Port specialized algorithms, encryption, math, and custom helpers.
+1. Translate raw logic with strict adherence to the exact mathematical and state behavior of the source.
+2. Provide **Unit Tests** in the target language to prove 100% computational parity with source output (especially for Base64, MD5/SHA, AES, timezone parsing).
+
+### Phase 4: UI & Presentation / Controller Layer 🎨
+**Purpose:** Rebuild user interfaces or API controllers utilizing the target's standard frameworks.
+1. Map source UI components to target equivalents (e.g., React to Compose, HTML/Jinja to Vue, Android XML to SwiftUI).
+2. For backend APIs: Convert source controller route handling to modern target framework routing (e.g., Express.js to FastAPI, Spring Boot to Go Gin).
+3. Implement modern state management and reactive data flows native to the new ecosystem.
+
+### Phase 5: SDK Integration & Parity Quality Gate ✅
+**Purpose:** Finalize third-party setups and ensure feature completeness.
+1. Wire up heavy SDKs (Auth, Analytics, Push Notifications, Payment gateways) with target SDKs.
+2. Perform rigorous Parity Validation across:
+   - *Branch Coverage:* Ensure all `if/switch` edge cases from source were ported.
+   - *Endpoint Parity:* Ensure headers, bodies, status codes match output.
+   - *Visual Parity:* (If UI) Layout behaves correctly.
+
+---
+
+## 🚫 ANTI-PATTERNS
+
+```yaml
+never_do:
+  - Line-by-line verbatim syntax translation (e.g., writing Java code in Go syntax using 'for' instead of 'range', or ignoring Swift optionals to force unwrap like in C#).
+  - Use deprecated patterns in the target ecosystem just because the source used them.
+  - Skip extracting business rules before writing the target implementation.
+  - Alter encryption hashes / outputs — they must match the original exactly for server compatibility!
+  
+always_do:
+  - Write Idiomatic Code: Fully embrace the target language's design patterns, conventions, and error-handling features.
+  - Checkpoint and halt after generating the Ecosystem Dependency Matrix to let the user review framework choices.
+  - Build test suites to verify math and crypto translations against known source outputs.
+```
+
+---
+
+*ship-to-code v1.0.0 — Universal Code Porting Skill*
+*Created by Antigravity Team*

package/skills/short-maker/SKILL.md

@@ -0,0 +1,150 @@
+---
+name: short-maker
+description: |
+  Đạo diễn sản xuất video quảng cáo App (App Promo) bằng AI. Tự động hóa quy trình viết kịch bản AIDA,
+  quản lý storyboard qua ShortMaker Studio MCP Server, và gọi Google Flow (Veo 3) render video bối cảnh thật
+  kèm Native Voice. Hỗ trợ Mimic Mode bóc tách nội dung trending từ YouTube/TikTok.
+metadata:
+  stage: workflow
+  version: "2.0"
+  requires: "ShortMaker Studio (MCP Server), google-flow-cli, ffmpeg"
+  tags: [video, marketing, ads, app-promo, veo, gflow, tiktok, youtube, shorts, mcp]
+trigger: explicit
+activation_keywords:
+  - "/short"
+  - "/promo"
+  - "/mimic"
+  - "làm video tiktok"
+  - "chạy video flow"
+---
+
+# 🎬 Short Maker v2.0 (MCP Client Mode)
+
+> **Mục tiêu**: Tối đa hóa traffic miễn phí từ Video ngắn (TikTok, YouTube Shorts, Reels)
+> bằng cách tự động sản xuất video quảng cáo App với cấu trúc AIDA hoặc copy (Mimic) hook viral.
+
+## ⚠️ Prerequisites (BẮT BUỘC)
+
+Skill này hoạt động như **MCP Client** — mọi thao tác project/storyboard/render đều gọi qua **ShortMaker Studio MCP Server**.
+
+**Trước khi bắt đầu, KIỂM TRA:**
+1. ShortMaker Studio MCP Server đang chạy (IDE đã kết nối qua MCP config)
+2. Gọi thử `shortmaker_list_projects` — nếu thành công → MCP Server OK
+3. Google Flow auth: kiểm tra `~/.gflow/env` tồn tại. Nếu chưa:
+   ```bash
+   cd ~/Dev2/MacOS/Shortmaker/scripts/google-flow-cli && PYTHONPATH=. python3 gflow/cli/main.py auth
+   ```
+
+## 📡 Chế độ hoạt động (Triggers)
+
+- **Original Mode (`/promo`, `/short`)**: User nhập [Tên App + Tính năng]. AI đóng vai Giám đốc Marketing, lên kịch bản AIDA.
+- **Mimic Mode (`/mimic`)**: User cung cấp [Link YouTube/TikTok]. AI trích xuất transcript, phân tích Hook/Pacing, sau đó clone cấu trúc kịch bản đó nhưng áp dụng cho App của user.
+
+## 🧱 Quy trình hoạt động (Mandatory Flow)
+
+**Bảo vệ Credit**: Mọi video Veo 3 đều tốn 20 credit. TUYỆT ĐỐI không gọi render khi chưa có xác nhận từ người dùng qua bước Storyboard Review.
+
+### Giai đoạn 1: Bootstrap Project
+
+Gọi MCP tool để tạo project:
+```
+shortmaker_create_project(name: "FitWitness Promo", appName: "FitWitness", description: "30s TikTok promo")
+```
+→ Trả về `projectId` và `path`. Dùng `projectId` cho tất cả các bước sau.
+
+### Giai đoạn 2: Kịch Bản & Character Casting
+
+1. Sinh kịch bản `script.md` (dùng template `aida_script.md` hoặc `mimic_analyzer.md`).
+2. **Character Setup** — gọi MCP tool:
+   ```
+   shortmaker_setup_character(projectId: "...", prompt: "A young Vietnamese woman, long black hair...", seed: "123456")
+   ```
+3. **Xử lý ảnh tham chiếu**:
+   - User cung cấp ảnh → AI phân tích, viết `character_prompt`, copy ảnh vào project dir
+   - User không có ảnh → AI thiết kế character, gọi `generate-image` tạo mẫu
+4. **Actor Approval**: Trình bày ảnh cho User. CHỈ TIẾP TỤC khi User chốt nhân vật.
+
+### Giai đoạn 3: Storyboard (0 Cost)
+
+Gọi MCP tool lặp lại cho từng scene:
+```
+shortmaker_add_scene(
+  projectId: "...",
+  prompt: "A woman standing in a modern gym, looking at her phone...",
+  speech: "Tired of forgetting your workouts?",
+  duration: 8,
+  transition: "fade",
+  sceneType: "hook"
+)
+```
+
+**Quy tắc prompt**:
+- **ƯU TIÊN MÔI TRƯỜNG THẬT**: TUYỆT ĐỐI KHÔNG dùng Greenscreen/Chroma key mặc định
+- Character prompt sẽ được auto-prepend bởi MCP Server
+- BẮT BUỘC truyền `--seed` đã chốt khi render
+
+Sau khi thêm đủ scenes, hướng dẫn User mở **ShortMaker Studio** để review storyboard trực quan.
+Hoặc AI tự review bằng:
+```
+shortmaker_get_storyboard(projectId: "...")
+```
+
+Sửa scene nếu cần:
+```
+shortmaker_update_scene(projectId: "...", sceneId: "scene-01", speech: "Updated narration")
+```
+
+**CHỈ TIẾP TỤC khi User xác nhận đã duyệt xong Storyboard.**
+
+### Giai đoạn 4: Render (Batch)
+
+Gọi MCP tool:
+```
+shortmaker_trigger_render(projectId: "...", fadeDuration: 1.0, bgmVolume: 0.1)
+```
+
+User có thể theo dõi tiến trình trên ShortMaker Studio GUI.
+
+## 🔀 Hiệu ứng Chuyển Cảnh (Transitions)
+
+Các hiệu ứng được hỗ trợ (truyền vào `transition` khi `add_scene`):
+- `fade` — Chuyển mờ dần (mặc định)
+- `slideleft` / `slideright` — Trượt sang trái/phải
+- `wipeleft` / `wiperight` — Quét sang trái/phải
+- `circlecrop` — Thu nhỏ hình tròn
+- `dissolve` — Hòa tan
+- `none` — Cắt thẳng, không hiệu ứng
+
+## 🌿 Green Screen (Fallback Option)
+
+Nếu User ĐẶC BIỆT yêu cầu greenscreen:
+- Thêm "on a solid chroma green screen background" vào prompt scene
+- Render pipeline sẽ tự xử lý chroma key với background được cung cấp
+
+## 📁 Output Convention
+
+Projects được lưu tại `~/ShortMaker-Projects/<project-id>/`:
+```
+<project-id>/
+├── shortmaker.config.json    # Project config (auto-managed)
+├── storyboard.json           # Scene data (auto-managed)
+├── assets/                   # Character ref, BGM
+├── storyboard/               # Scene preview images
+├── segments/                 # Rendered video segments
+├── tts/                      # TTS audio files
+├── temp/                     # Temporary processing files
+└── final/                    # Final mixed output
+```
+
+## 🔧 MCP Tools Reference
+
+| Tool | Mục đích |
+|------|----------|
+| `shortmaker_list_projects` | Liệt kê projects hiện có |
+| `shortmaker_create_project` | Tạo project mới |
+| `shortmaker_setup_character` | Chốt nhân vật (prompt + seed) |
+| `shortmaker_add_scene` | Thêm scene vào storyboard |
+| `shortmaker_update_scene` | Sửa scene đã có |
+| `shortmaker_get_storyboard` | Xem toàn bộ storyboard |
+| `shortmaker_trigger_render` | Bắt đầu render pipeline (async, chạy ngầm) |
+| `shortmaker_get_render_status` | Kiểm tra tiến trình render đang chạy (polling) |

package/skills/short-maker/_backup/storyboard.html

@@ -0,0 +1,106 @@
+<!DOCTYPE html>
+<html lang="vi">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Storyboard Preview</title>
+  <style>
+    :root {
+      --bg: #121212; --card-bg: #1E1E1E; --text: #E0E0E0; --accent: #BB86FC; --accent-hover: #9965f4;
+    }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+      background-color: var(--bg); color: var(--text); padding: 20px;
+    }
+    header { text-align: center; margin-bottom: 30px; }
+    h1 { margin: 0; color: var(--accent); }
+    .meta { color: #888; font-size: 0.9em; margin-top: 5px; }
+    .grid {
+      display: grid; grid-template-columns: repeat(auto-fill, minmax(320px, 1fr)); gap: 20px;
+    }
+    .card {
+      background: var(--card-bg); border-radius: 12px; overflow: hidden;
+      box-shadow: 0 4px 6px rgba(0,0,0,0.3); border: 1px solid #333;
+    }
+    .card-img-wrapper { position: relative; padding-top: 56.25%; /* 16:9 Aspect Ratio */ background: #000; }
+    .card img {
+      position: absolute; top: 0; left: 0; width: 100%; height: 100%; object-fit: cover;
+    }
+    .scene-number {
+      position: absolute; top: 10px; left: 10px; background: rgba(0,0,0,0.7);
+      color: #fff; padding: 4px 8px; border-radius: 6px; font-weight: bold; font-size: 0.8em;
+    }
+    .card-content { padding: 15px; }
+    .duration { color: var(--accent); font-weight: bold; font-size: 0.9em; margin-bottom: 8px; }
+    .script { font-size: 1em; line-height: 1.4; margin-bottom: 12px; }
+    .prompt { font-size: 0.8em; color: #888; font-style: italic; background: #2a2a2a; padding: 8px; border-radius: 6px; }
+    .timeline-bar {
+      height: 6px; background: #333; margin-top: 30px; border-radius: 3px; position: relative; overflow: hidden;
+    }
+    .timeline-progress { height: 100%; background: var(--accent); width: 0%; }
+  </style>
+</head>
+<body>
+
+  <header>
+    <h1 id="title">Loading Storyboard...</h1>
+    <div class="meta" id="meta">Duration: 0s</div>
+  </header>
+  
+  <div class="timeline-bar">
+    <div class="timeline-progress" id="timeline"></div>
+  </div>
+
+  <div class="grid" id="grid">
+    <!-- Cards will be injected here -->
+  </div>
+
+  <script>
+    async function loadStoryboard() {
+      try {
+        // Fetch expects storyboard.json in the same directory
+        const response = await fetch('storyboard.json');
+        const data = await response.json();
+        
+        document.getElementById('title').textContent = data.title || 'App Promo Storyboard';
+        document.getElementById('meta').textContent = `Total Duration: ${data.duration || 0}s | Video Target: ${data.target_format || '16:9'}`;
+        
+        const grid = document.getElementById('grid');
+        grid.innerHTML = '';
+        
+        let totalTime = data.duration || 1; // avoid /0
+        let cumulative = 0;
+        
+        data.scenes.forEach((scene, index) => {
+          cumulative += scene.duration;
+          
+          const card = document.createElement('div');
+          card.className = 'card';
+          card.innerHTML = `
+            <div class="card-img-wrapper">
+              <img src="${scene.image || 'https://via.placeholder.com/640x360?text=Generating+Image...'}" alt="Scene ${scene.id}">
+              <div class="scene-number">Scene ${scene.id}</div>
+            </div>
+            <div class="card-content">
+              <div class="duration">⏱️ ${scene.duration}s</div>
+              <div class="script">🎙️ "${scene.script}"</div>
+              <div class="prompt">🎨 Prompt: ${scene.prompt}</div>
+            </div>
+          `;
+          grid.appendChild(card);
+        });
+        
+        // Setup dumb timeline animation for fun
+        const timeline = document.getElementById('timeline');
+        timeline.style.width = '100%';
+        timeline.style.transition = `width ${data.duration}s linear`;
+      } catch (e) {
+        document.getElementById('title').innerHTML = `<span style="color:red">Error Loading storyboard.json</span>`;
+        console.error(e);
+      }
+    }
+    
+    loadStoryboard();
+  </script>
+</body>
+</html>

package/skills/short-maker/_backup/video_mixer.py

@@ -0,0 +1,296 @@
+import argparse
+import glob
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+def get_duration(filepath: Path) -> float:
+    cmd = [
+        "ffprobe",
+        "-v", "error",
+        "-show_entries", "format=duration",
+        "-of", "default=noprint_wrappers=1:nokey=1",
+        str(filepath)
+    ]
+    try:
+        output = subprocess.check_output(cmd, text=True).strip()
+        return float(output)
+    except Exception as e:
+        print(f"Error getting duration for {filepath}: {e}")
+        return 0.0
+
+
+def check_has_audio(filepath: Path) -> bool:
+    cmd = [
+        "ffprobe", "-v", "error",
+        "-select_streams", "a",
+        "-show_entries", "stream=codec_type",
+        "-of", "csv=p=0",
+        str(filepath)
+    ]
+    try:
+        output = subprocess.check_output(cmd, text=True).strip()
+        return len(output) > 0
+    except Exception:
+        return False
+
+
+def ensure_dir(path: Path) -> Path:
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+# Supported FFmpeg xfade transitions
+SUPPORTED_TRANSITIONS = [
+    'fade', 'slideleft', 'slideright', 'circlecrop',
+    'dissolve', 'wipeleft', 'wiperight',
+    'smoothleft', 'smoothright', 'smoothup', 'smoothdown',
+]
+
+
+def load_storyboard_transitions(project_dir: Path) -> list:
+    """Read per-scene transitions from storyboard.json if available."""
+    sb_path = project_dir / "storyboard.json"
+    if not sb_path.exists():
+        return []
+    try:
+        with open(sb_path, 'r') as f:
+            data = json.load(f)
+        transitions = []
+        for scene in data.get('scenes', []):
+            t = scene.get('transition', 'fade')
+            if t not in SUPPORTED_TRANSITIONS:
+                t = 'fade'
+            transitions.append(t)
+        return transitions
+    except Exception as e:
+        print(f"Warning: Could not read storyboard.json: {e}")
+        return []
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Auto-Mixer cho Short Maker bằng FFmpeg")
+    parser.add_argument("--project-dir", required=True, help="Thư mục project chứa outputs (ví dụ: outputs/promo-app)")
+    parser.add_argument("--fade-duration", type=float, default=1.0, help="Thời gian crossfade giữa các cảnh (giây)")
+    parser.add_argument("--bgm-volume", type=float, default=0.1, help="Âm lượng nhạc nền (0.0 đến 1.0)")
+    parser.add_argument("--chroma-bg", type=str, help="Đường dẫn đến ảnh/video nền để thay thế phông xanh")
+    parser.add_argument("--chroma-color", type=str, default="0x00FF00", help="Mã màu phông xanh (mặc định: 0x00FF00)")
+    parser.add_argument("--chroma-sim", type=float, default=0.3, help="Độ tương đồng màu (0.01 - 1.0, mặc định: 0.3)")
+    parser.add_argument("--chroma-blend", type=float, default=0.2, help="Độ mượt viền (0.0 - 1.0, mặc định: 0.2)")
+    args = parser.parse_args()
+
+    project_dir = Path(args.project_dir)
+    segments_dir = project_dir / "segments"
+    tts_dir = project_dir / "tts"
+    audio_dir = project_dir / "audio"
+    temp_dir = ensure_dir(project_dir / "temp")
+    final_dir = ensure_dir(project_dir / "final")
+
+    if not segments_dir.exists() or not tts_dir.exists():
+        print(f"Error: Thư mục segments hoặc tts không tồn tại trong {project_dir}")
+        sys.exit(1)
+
+    # Liệt kê các cảnh
+    video_files = sorted(glob.glob(str(segments_dir / "*.mp4")))
+    if not video_files:
+        print("Không tìm thấy video nào trong segments/")
+        sys.exit(1)
+
+    scenes = []
+    for v_path in video_files:
+        v_path = Path(v_path)
+        scene_name = v_path.stem  # vd: scene-01
+        
+        # Tìm file TTS tương ứng (mp3 hoặc wav)
+        tts_path = tts_dir / f"{scene_name}.mp3"
+        if not tts_path.exists():
+            tts_path = tts_dir / f"{scene_name}.wav"
+            
+        if not tts_path.exists():
+            print(f"Thêm cảnh {scene_name} nhưng KHÔNG có file âm thanh TTS.")
+            scenes.append({"video": v_path, "audio": None})
+        else:
+            scenes.append({"video": v_path, "audio": tts_path})
+
+    print(f"Bắt đầu mix {len(scenes)} cảnh...")
+
+    # Bước 1: Render từng cảnh riêng lẻ (Loop video để khớp với audio)
+    ready_scenes = []
+    for idx, scene in enumerate(scenes):
+        out_scene = temp_dir / f"ready_{idx:02d}.mp4"
+        ready_scenes.append(out_scene)
+        
+        # Tiết kiệm thời gian nếu render rồi
+        if out_scene.exists():
+            print(f" - [Skip] Cảnh {idx+1} đã được chuẩn bị.")
+            continue
+
+        print(f" - [Render] Chuẩn bị cảnh {idx+1}...")
+        if scene["audio"]:
+            # Dùng stream_loop để loop video nếu nó ngắn hơn audio
+            cmd = [
+                "ffmpeg", "-y",
+                "-stream_loop", "-1", "-i", str(scene["video"]),
+                "-i", str(scene["audio"]),
+                "-c:v", "libx264", "-c:a", "aac",
+                "-map", "0:v:0", "-map", "1:a:0",
+                "-shortest", "-pix_fmt", "yuv420p",
+                str(out_scene)
+            ]
+        else:
+            # Ưu tiên Native Voice của Veo 3 nếu không có file TTS ngoài.
+            # Nếu video không có audio stream, thêm audio âm câm để mix tránh lỗi acrossfade.
+            has_audio = check_has_audio(scene["video"])
+            if has_audio:
+                cmd = [
+                    "ffmpeg", "-y",
+                    "-i", str(scene["video"]),
+                    "-c:v", "libx264", "-c:a", "aac", "-pix_fmt", "yuv420p",
+                    str(out_scene)
+                ]
+            else:
+                cmd = [
+                    "ffmpeg", "-y",
+                    "-f", "lavfi", "-i", "anullsrc=channel_layout=stereo:sample_rate=44100",
+                    "-i", str(scene["video"]),
+                    "-c:v", "libx264", "-c:a", "aac",
+                    "-map", "1:v:0", "-map", "0:a:0",
+                    "-shortest", "-pix_fmt", "yuv420p",
+                    str(out_scene)
+                ]
+        
+        subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+
+    # Bước 2: Ghép các cảnh bằng XFade (Chuyển cảnh nhẹ nhàng)
+    # Load per-scene transitions from storyboard.json
+    scene_transitions = load_storyboard_transitions(project_dir)
+    print("Bắt đầu Crossfade nối màn...")
+    merged_output = temp_dir / "merged_crossfaded.mp4"
+    fade_d = args.fade_duration
+
+    if len(ready_scenes) == 1:
+        merged_output = ready_scenes[0]
+    else:
+        # Tính toán duration để tính offset
+        durations = [get_duration(f) for f in ready_scenes]
+        
+        filter_complex = ""
+        inputs = []
+        
+        for i, sc in enumerate(ready_scenes):
+            inputs.extend(["-i", str(sc)])
+
+        offsets = []
+        current_offset = 0.0
+        
+        for i in range(len(durations) - 1):
+            current_offset += durations[i] - fade_d
+            offsets.append(current_offset)
+
+        # Build video filter with per-scene transitions
+        v_labels = [f"[{i}:v]" for i in range(len(ready_scenes))]
+        for i in range(len(offsets)):
+            # Get transition for this join (from scene i to i+1)
+            transition_type = 'fade'  # default
+            if i < len(scene_transitions):
+                t = scene_transitions[i]
+                if t != 'none':
+                    transition_type = t
+            
+            last_out = v_labels[0]
+            next_in = v_labels[i+1]
+            out_label = f"[v{i+1}]"
+            
+            if i < len(scene_transitions) and scene_transitions[i] == 'none':
+                # No transition — simple concat (handled by offset = duration)
+                filter_complex += f"{last_out}{next_in}xfade=transition=fade:duration=0.01:offset={offsets[i]}{out_label}; "
+            else:
+                filter_complex += f"{last_out}{next_in}xfade=transition={transition_type}:duration={fade_d}:offset={offsets[i]}{out_label}; "
+            v_labels[0] = out_label  # Cập nhật pipe hiện tại
+            
+            print(f"   Scene {i+1} → {i+2}: transition={transition_type}")
+        
+        # Build audio filter
+        a_labels = [f"[{i}:a]" for i in range(len(ready_scenes))]
+        for i in range(len(offsets)):
+            last_out = a_labels[0]
+            next_in = a_labels[i+1]
+            out_label = f"[a{i+1}]"
+            filter_complex += f"{last_out}{next_in}acrossfade=d={fade_d}{out_label}; "
+            a_labels[0] = out_label
+
+        cmd_merge = ["ffmpeg", "-y"] + inputs + [
+            "-filter_complex", filter_complex.strip(" ;"),
+            "-map", v_labels[0],
+            "-map", a_labels[0],
+            "-c:v", "libx264", "-c:a", "aac", "-pix_fmt", "yuv420p",
+            str(merged_output)
+        ]
+        
+        print("   Đang render crossfade... (có thể mất vài phút)")
+        subprocess.run(cmd_merge, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+
+    # Bước 2.5: Ghép hình nền tách phông xanh (nếu có)
+    if args.chroma_bg and os.path.exists(args.chroma_bg):
+        print(f"Bắt đầu tách phông xanh và ghép nền: {args.chroma_bg}...")
+        merged_chroma = temp_dir / "merged_chroma.mp4"
+        bg_ext = Path(args.chroma_bg).suffix.lower()
+        is_image = bg_ext in ['.png', '.jpg', '.jpeg']
+
+        filter_complex = (
+            f"[0:v][1:v]scale2ref=w=iw:h=ih[bg][ref];"
+            f"[ref]colorkey={args.chroma_color}:{args.chroma_sim}:{args.chroma_blend}[ckout];"
+            f"[bg][ckout]overlay=shortest=1"
+        )
+
+        if is_image:
+            cmd_chroma = [
+                "ffmpeg", "-y",
+                "-loop", "1", "-framerate", "30", "-i", str(args.chroma_bg),
+                "-i", str(merged_output),
+                "-filter_complex", filter_complex,
+                "-c:v", "libx264", "-c:a", "copy", "-pix_fmt", "yuv420p",
+                str(merged_chroma)
+            ]
+        else:
+            cmd_chroma = [
+                "ffmpeg", "-y",
+                "-stream_loop", "-1", "-i", str(args.chroma_bg),
+                "-i", str(merged_output),
+                "-filter_complex", filter_complex,
+                "-c:v", "libx264", "-c:a", "copy", "-pix_fmt", "yuv420p",
+                str(merged_chroma)
+            ]
+        
+        subprocess.run(cmd_chroma, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+        merged_output = merged_chroma
+
+    # Bước 3: Lồng nhạc nền
+    bgm_file = audio_dir / "bgm.mp3"
+    final_output = final_dir / "promo-final.mp4"
+    
+    if bgm_file.exists():
+        print(f"Mix nhạc nền (âm lượng {args.bgm_volume})...")
+        cmd_bgm = [
+            "ffmpeg", "-y",
+            "-i", str(merged_output),
+            "-stream_loop", "-1", "-i", str(bgm_file),
+            "-filter_complex", f"[1:a]volume={args.bgm_volume}[bgm];[0:a][bgm]amix=inputs=2:duration=first:dropout_transition=2[a]",
+            "-map", "0:v:0", "-map", "[a]",
+            "-c:v", "copy", "-c:a", "aac",
+            str(final_output)
+        ]
+        subprocess.run(cmd_bgm, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+    else:
+        print("Không tìm thấy bgm.mp3, bỏ qua mix nhạc nền.")
+        import shutil
+        shutil.copy(merged_output, final_output)
+
+    print(f"\n✅ Hoàn tất! Video lưu tại: {final_output}")
+
+
+if __name__ == "__main__":
+    main()