@leejungkiin/awkit 1.7.1 → 1.7.4

package/skills/ios-visual-qa-strategist/references/visual-reasoning-heuristics.md

@@ -0,0 +1,53 @@
+# Visual Reasoning Heuristics
+
+Inspect screenshots like a focused QA pass, not like a design critique.
+
+## First Pass
+
+Identify:
+
+- current screen name or purpose
+- visible user state: logged out, logged in, onboarding, loading, empty, error, populated, editing, confirming
+- primary and secondary actions
+- whether the screen matches the expected step in the test plan
+
+## Layout Checks
+
+Look for:
+
+- clipped text, truncated labels, ellipses on critical content
+- overlapping views, stacked buttons, hidden controls
+- safe-area issues at top, bottom, keyboard, Dynamic Island, notch, and home indicator
+- scrollability when content exceeds viewport
+- tap targets that appear too small or crowded
+- modal/sheet height problems
+- keyboard covering input or submit buttons
+
+## Content Checks
+
+Look for:
+
+- placeholder content leaking into production flows
+- stale loading indicators
+- empty state copy that does not match the action available
+- inconsistent numbers, dates, currency, units, or language
+- missing required data after save/import/sync
+- destructive actions without clear confirmation
+
+## State Inference
+
+Use caution when inferring:
+
+- success from a screen transition alone
+- network completion from a spinner disappearing
+- persistence from visible text before app relaunch
+- analytics/tracking from UI state
+- permission correctness from a prompt appearing
+
+When inference is not enough, pair the screenshot with logs, accessibility assertions, app relaunch, or a deterministic test.
+
+## Confidence Labels
+
+- High: the screenshot directly shows the claim or a deterministic assertion confirms it.
+- Medium: the visible state plus accessibility/log evidence supports the claim.
+- Low: the claim depends on code/spec inference without direct observation.

package/skills/orchestrator/SKILL.md

@@ -68,25 +68,5 @@ No match → Ask clarifying question (max 2 times)
 Still unclear → Suggest `/help`
 ```
 
-### 5. Model Fitness Check (Pre-Execution Gate)
-```yaml
-model_fitness_gate:
-  purpose: "Đúng mô hình — đúng việc — tránh lãng phí token và tránh hallucination do mismatch."
-  action: "Orchestrator must analyze task complexity vs current model tier before code execution."
-  tiers:
-    - LIGHT: Flash/Haiku/4o-mini (config, syntax, docs, simple boilerplate)
-    - STANDARD: Pro/Sonnet/4o (90% dev work, active coding, feature additions, standard bug fixes)
-    - HEAVY: Opus/Ultra/o1/o3 (Architecture, custom framework, refactor > 5 files, deep debugging)
-  detect_signals:
-    escalate_if: "Blast radius > 5 files, ≥ 2 custom types (e.g. protocol matching), COMPLEX triage, circular self-correction"
-    downgrade_if: "Single file < 20 lines, *.plist|*.json|*.env, string replacements, no logic changes"
-  procedure:
-    1: "Phân loại mức độ phức tạp của Task để chốt Hạng Yêu Cầu (Required Tier) (tham khảo project-identity modelPolicy hoặc tự nội suy)."
-    2: "Chú ý Môi trường IDE (Cursor, Gemini) -> AI KHÔNG THỂ tự động đổi Model."
-    3: "Nếu phát hiện Mismatch (Over-fit lãng phí token như dùng Opus cho task dễ, HOẶC Under-fit sinh lỗi như dùng Flash cho task khó) -> Print ⚠️ MODEL TRIAGE CHECKPOINT và BẮT BUỘC DỪNG quá trình."
-    4: "Yêu cầu user tự chuyển đổi model trên IDE hoặc gõ 'Tiếp tục' để ép buộc chạy model hiện tại."
-    5: "Nếu Match (Đạt yêu cầu) -> Tiếp tục chạy bình thường."
-```
-
 ## Auto-Activation
 This skill is always active. It runs as the first layer before any other processing.

package/skills/persistent-storage/SKILL.md

@@ -0,0 +1,55 @@
+# SKILL: persistent-storage
+
+Cung cấp API và cơ chế lưu trữ dữ liệu key-value bền vững (persistent key-value storage) cho các tài liệu tương tác (Artifacts) trong Antigravity.
+
+---
+
+## 🛠️ API Định nghĩa (Storage API)
+
+Các Artifacts tương tác (HTML/JS chạy trên browser) có thể tương tác với storage thông qua các hàm bất đồng bộ. Đối với AI Agent, bạn có thể gọi trực tiếp thông qua công cụ dòng lệnh (CLI):
+
+```bash
+awkit storage set <key> '<json_value>' [--shared]
+awkit storage get <key> [--shared]
+awkit storage delete <key> [--shared]
+awkit storage list [prefix] [--shared]
+```
+
+### 1. `storage_get(key, shared?)`
+- **Mục tiêu:** Lấy giá trị tương ứng với key.
+- **Tham số:** 
+  - `key` (String): Độ dài dưới 200 ký tự. Không chứa khoảng trắng, dấu ngoặc kép hoặc dấu gạch chéo.
+  - `shared` (Boolean, mặc định: `false`): Nếu `true`, dữ liệu có thể được truy cập bởi tất cả người dùng của artifact đó. Nếu `false`, chỉ người dùng hiện tại truy cập được.
+- **Kết quả trả về:** `{ key, value, shared }` hoặc `null` nếu không tìm thấy key (hoặc báo lỗi nếu truy vấn thất bại).
+
+### 2. `storage_set(key, value, shared?)`
+- **Mục tiêu:** Lưu trữ hoặc cập nhật giá trị.
+- **Tham số:**
+  - `key` (String)
+  - `value` (String/JSON): Dung lượng tối đa 5MB.
+  - `shared` (Boolean)
+- **Kết quả trả về:** `{ key, value, shared }` khi thành công.
+
+### 3. `storage_delete(key, shared?)`
+- **Mục tiêu:** Xóa key.
+- **Kết quả trả về:** `{ key, deleted: true, shared }` khi thành công.
+
+### 4. `storage_list(prefix?, shared?)`
+- **Mục tiêu:** Liệt kê các key có prefix được chỉ định.
+- **Kết quả trả về:** Danh sách các keys khớp.
+
+---
+
+## 💾 Cơ chế Lưu trữ Cục bộ (Local Persistence Engine)
+
+Tại môi trường runtime, dữ liệu được ánh xạ trực tiếp và lưu trữ bền vững theo hai phương án:
+1. **SQLite Database (Sử dụng Symphony DB):** Lưu vào bảng `artifact_storage` với cấu trúc `(key TEXT PRIMARY KEY, value TEXT, shared INTEGER, updated_at TIMESTAMP)`.
+2. **File JSON Cục bộ (Chế độ offline):** Lưu trực tiếp vào `.brain/storage.json` của dự án hiện tại.
+
+---
+
+## 💡 Best Practices cho Thiết kế Artifacts
+
+- **Đặt key theo cấp bậc (Hierarchical Keys):** Sử dụng dạng `table_name:record_id` (ví dụ: `todos:todo_1`, `settings:global`).
+- **Gom nhóm dữ liệu (Batching):** Hạn chế gọi API ghi/đọc liên tục. Hãy gom các dữ liệu liên quan vào cùng một object JSON lớn để lưu trữ trong một key duy nhất (ví dụ: thay vì lưu từng pixel art, hãy lưu cả ma trận pixel của bảng).
+- **Xử lý lỗi (Error Handling):** Bắt buộc sử dụng khối `try-catch` khi gọi các hàm storage. Hiển thị loading indicators hoặc giao diện mềm dẻo cho người dùng thay vì block UI khi truy xuất dữ liệu thất bại.

package/skills/short-maker/SKILL.md

@@ -136,6 +136,28 @@ Projects được lưu tại `~/ShortMaker-Projects/<project-id>/`:
 └── final/                    # Final mixed output
 ```
 
+## 🎞️ Video Editing & Rendering Engine (macOS & Node.js)
+
+Skill này tích hợp bộ biên tập video tự động thay thế cho pipeline PowerShell cũ, tương thích hoàn toàn với macOS:
+
+### 1. Storyboard Bridge (`scripts/shortmaker-bridge.js`)
+Dùng để chuyển đổi `storyboard.json` từ ShortMaker sang định dạng EDL chuẩn:
+- **Tải nhạc từ Pixabay**: Tự động tìm kiếm video chủ đề background music, tải xuống và trích xuất audio thành `music.mp3` nếu có `PIXABAY_API_KEY` (fallback về SoundHelix nhạc royalty-free).
+- **Tự động hoạt ảnh hóa (Screenshot Animation)**: Nếu không có video segment trong `segments/`, bridge sẽ sử dụng thư viện `effects.js` áp dụng bộ lọc Ken Burns (`zoom-in`, `zoom-out`, `pan-left`, `pan-right`) biến các screenshot tĩnh (`image`) thành video clip.
+- **Audio Ducking**: Tự động dìm nhạc nền (xuống `0.15`) trong suốt thời gian có giọng đọc TTS.
+
+**Cách chạy:**
+```bash
+node scripts/shortmaker-bridge.js --project-dir=<path-to-shortmaker-project> --out-dir=<path-to-videomix-output> [--bgm-volume=0.2]
+```
+
+### 2. VideoMix CLI (`scripts/videomix.js`)
+Bộ CLI lõi để bootstrap, render và QA video:
+- **Tạo dự án**: `node scripts/videomix.js new:cinematic <edl.json> <out-dir> --force` (tạo thư mục, cắt/chuẩn hóa âm thanh và video shot, tạo index.html).
+- **Render**: `node scripts/videomix.js render <project-dir>` (chạy hyperframes lint, validate, render).
+- **QA**: `node scripts/videomix.js qa <project-dir>` (phát hiện frame đen blackdetect và chụp ảnh kiểm chứng).
+- **Video dọc**: `node scripts/videomix.js vertical <input.mp4> <output.mp4>` (sinh video 9:16 với blur background).
+
 ## 🔧 MCP Tools Reference
 
 | Tool | Mục đích |
@@ -148,3 +170,4 @@ Projects được lưu tại `~/ShortMaker-Projects/<project-id>/`:
 | `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/scripts/effects.js

@@ -0,0 +1,56 @@
+const { execSync } = require('child_process');
+
+/**
+ * Generate the zoompan filter based on selected effect.
+ */
+function getZoompanFilter({ effect = 'zoom-in', durationSec = 5, fps = 30, width = 1080, height = 1920 }) {
+    const totalFrames = Math.ceil(durationSec * fps);
+    let filter = '';
+
+    switch (effect) {
+        case 'zoom-in':
+            filter = `zoompan=z='min(zoom+0.001,1.15)':x='iw/2-(iw/zoom/2)':y='ih/2-(ih/zoom/2)'`;
+            break;
+        case 'zoom-out':
+            filter = `zoompan=z='max(1.15-0.001*on,1.0)':x='iw/2-(iw/zoom/2)':y='ih/2-(ih/zoom/2)'`;
+            break;
+        case 'pan-left':
+            filter = `zoompan=z='1.2':x='(1.2-1)*iw * (1 - on/${totalFrames})':y='ih/2-(ih/zoom/2)'`;
+            break;
+        case 'pan-right':
+            filter = `zoompan=z='1.2':x='(1.2-1)*iw * (on/${totalFrames})':y='ih/2-(ih/zoom/2)'`;
+            break;
+        case 'still':
+        default:
+            return `scale=${width}:${height}:force_original_aspect_ratio=increase,crop=${width}:${height},format=yuv420p`;
+    }
+
+    return `${filter}:d=${totalFrames}:s=${width}x${height},format=yuv420p`;
+}
+
+/**
+ * Animate a static image into a short MP4 clip using FFmpeg.
+ */
+function animateScreenshot(inputPath, outputPath, options = {}) {
+    const {
+        effect = 'zoom-in',
+        durationSec = 5,
+        fps = 30,
+        width = 1080,
+        height = 1920
+    } = options;
+
+    const filter = getZoompanFilter({ effect, durationSec, fps, width, height });
+    const cmd = `ffmpeg -hide_banner -y -loop 1 -i "${inputPath}" -vf "${filter}" -c:v libx264 -preset veryfast -crf 20 -t ${durationSec} -pix_fmt yuv420p "${outputPath}"`;
+    
+    try {
+        execSync(cmd, { stdio: 'pipe' });
+    } catch (err) {
+        throw new Error(`FFmpeg animateScreenshot failed: ${err.stderr ? err.stderr.toString() : err.message}`);
+    }
+}
+
+module.exports = {
+    animateScreenshot,
+    getZoompanFilter
+};

package/skills/short-maker/scripts/shortmaker-bridge.js

@@ -0,0 +1,332 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { animateScreenshot } = require('./effects');
+
+// Fallback music URL if Pixabay key is missing or API fails
+const FALLBACK_MUSIC_URL = 'https://www.soundhelix.com/examples/mp3/SoundHelix-Song-1.mp3';
+
+/**
+ * Helper to fetch and download a file.
+ */
+async function downloadFile(url, destPath) {
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`Failed to download from ${url}: ${res.statusText}`);
+    const buffer = Buffer.from(await res.arrayBuffer());
+    fs.writeFileSync(destPath, buffer);
+}
+
+/**
+ * Locate Pixabay API Key from env, project .env, or global config.
+ */
+function getPixabayApiKey() {
+    if (process.env.PIXABAY_API_KEY) return process.env.PIXABAY_API_KEY;
+    if (process.env.PIXABAY_KEY) return process.env.PIXABAY_KEY;
+
+    // Check local .env
+    const envPath = path.join(process.cwd(), '.env');
+    if (fs.existsSync(envPath)) {
+        try {
+            const content = fs.readFileSync(envPath, 'utf8');
+            const match = content.match(/^PIXABAY_API_KEY\s*=\s*(.+)$/m);
+            if (match) return match[1].trim().replace(/['"]/g, '');
+        } catch (_) {}
+    }
+
+    return null;
+}
+
+/**
+ * Search Pixabay for videos matching a background music query, and return a download URL.
+ */
+async function fetchPixabayBgmUrl(apiKey) {
+    const queries = ['lofi+beats', 'ambient+background+music', 'instrumental+music', 'cinematic+music'];
+    const query = queries[Math.floor(Math.random() * queries.length)];
+    const url = `https://pixabay.com/api/videos/?key=${apiKey}&q=${encodeURIComponent(query)}&per_page=10`;
+
+    try {
+        const res = await fetch(url);
+        if (!res.ok) throw new Error(`Pixabay API status: ${res.status}`);
+        const data = await res.json();
+        
+        if (data.hits && data.hits.length > 0) {
+            const hit = data.hits[Math.floor(Math.random() * data.hits.length)];
+            const videoUrl = hit.videos.medium?.url || hit.videos.small?.url || hit.videos.large?.url;
+            if (videoUrl) {
+                console.log(`[Bridge] Found Pixabay video clip for BGM: ${hit.pageURL}`);
+                return { videoUrl, isVideo: true };
+            }
+        }
+    } catch (err) {
+        console.warn(`[Bridge] Warning: Pixabay search failed: ${err.message}`);
+    }
+    return null;
+}
+
+/**
+ * Get media duration using ffprobe.
+ */
+function getMediaDuration(filepath) {
+    try {
+        const output = execSync(
+            `ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 "${filepath}"`,
+            { encoding: 'utf-8', timeout: 5000 }
+        ).trim();
+        return parseFloat(output) || 0;
+    } catch (e) {
+        return 0;
+    }
+}
+
+/**
+ * Map storyboard transition effect to effects.js standard animations.
+ */
+function mapEffect(effectName) {
+    if (!effectName) return 'zoom-in';
+    const norm = effectName.toLowerCase();
+    if (norm.includes('push_in') || norm.includes('zoom_in') || norm.includes('zoom-in')) {
+        return 'zoom-in';
+    }
+    if (norm.includes('zoom_out') || norm.includes('zoom-out') || norm.includes('pulse')) {
+        return 'zoom-out';
+    }
+    if (norm.includes('pan') && (norm.includes('left') || norm.includes('vertical'))) {
+        return 'pan-left';
+    }
+    if (norm.includes('pan') && norm.includes('right')) {
+        return 'pan-right';
+    }
+    return 'still';
+}
+
+/**
+ * Run the Bridge process.
+ */
+async function runBridge({ shortmakerDir, outDir, bgmVolume = 0.2 }) {
+    console.log(`[Bridge] Importing ShortMaker project from: ${shortmakerDir}`);
+    
+    const sbPath = path.join(shortmakerDir, 'storyboard.json');
+    if (!fs.existsSync(sbPath)) {
+        throw new Error(`storyboard.json not found in ${shortmakerDir}`);
+    }
+
+    const sb = JSON.parse(fs.readFileSync(sbPath, 'utf8'));
+    const scenes = sb.scenes || [];
+    if (scenes.length === 0) {
+        throw new Error('Storyboard has no scenes.');
+    }
+
+    // Ensure output directories exist
+    fs.mkdirSync(outDir, { recursive: true });
+    const mediaDir = path.join(outDir, 'media');
+    fs.mkdirSync(mediaDir, { recursive: true });
+
+    // 1. Identify/Download Music BGM
+    const bgmOut = path.join(mediaDir, 'music.mp3');
+    let bgmSourceUsed = 'fallback';
+
+    const apiKey = getPixabayApiKey();
+    if (apiKey) {
+        console.log('[Bridge] Pixabay API Key found. Searching Pixabay for BGM source...');
+        const bgmData = await fetchPixabayBgmUrl(apiKey);
+        if (bgmData) {
+            const tempVideo = path.join(outDir, 'temp_bgm_video.mp4');
+            try {
+                console.log(`[Bridge] Downloading Pixabay video clip: ${bgmData.videoUrl}`);
+                await downloadFile(bgmData.videoUrl, tempVideo);
+                
+                console.log('[Bridge] Extracting audio track to bgm.mp3...');
+                execSync(`ffmpeg -hide_banner -y -i "${tempVideo}" -vn -c:a libmp3lame -b:a 192k "${bgmOut}"`, { stdio: 'ignore' });
+                bgmSourceUsed = 'pixabay';
+            } catch (err) {
+                console.warn(`[Bridge] Pixabay download/extract failed: ${err.message}. Falling back to default.`);
+            } finally {
+                if (fs.existsSync(tempVideo)) fs.unlinkSync(tempVideo);
+            }
+        }
+    }
+
+    if (bgmSourceUsed === 'fallback') {
+        let localMusic = sb.audio?.music;
+        if (localMusic) {
+            if (!path.isAbsolute(localMusic)) {
+                localMusic = path.resolve(shortmakerDir, localMusic);
+            }
+            if (fs.existsSync(localMusic)) {
+                console.log(`[Bridge] Copying BGM from storyboard configuration: ${localMusic}`);
+                fs.copyFileSync(localMusic, bgmOut);
+                bgmSourceUsed = 'storyboard-local';
+            }
+        }
+        
+        if (bgmSourceUsed === 'fallback') {
+            console.log(`[Bridge] Downloading fallback BGM: ${FALLBACK_MUSIC_URL}`);
+            await downloadFile(FALLBACK_MUSIC_URL, bgmOut);
+        }
+    }
+
+    // 2. Parse Scenes and build EDL
+    console.log('[Bridge] Mapping storyboard scenes to EDL format...');
+    const shots = [];
+    const dialogue = [];
+    const captions = [];
+
+    let currentTimelineStart = 0;
+    const duckingIntervals = [];
+
+    const screenshotsDir = sb.inputs?.screenshotsDir 
+        ? (path.isAbsolute(sb.inputs.screenshotsDir) ? sb.inputs.screenshotsDir : path.resolve(shortmakerDir, sb.inputs.screenshotsDir))
+        : path.join(shortmakerDir, 'assets');
+
+    for (let i = 0; i < scenes.length; i++) {
+        const scene = scenes[i];
+        const sceneIndexStr = String(i + 1).padStart(2, '0');
+        const id = scene.id || `shot-${sceneIndexStr}`;
+        
+        let videoFile = path.join(shortmakerDir, 'segments', `${scene.id || `scene-${sceneIndexStr}`}.mp4`);
+        if (!fs.existsSync(videoFile)) {
+            videoFile = path.join(shortmakerDir, 'segments', `scene-${sceneIndexStr}.mp4`);
+        }
+
+        const targetVideoFile = `shot-${sceneIndexStr}.mp4`;
+        const targetVideoPath = path.join(mediaDir, targetVideoFile);
+        let sceneDuration = parseFloat(scene.duration) || 5.0;
+
+        if (fs.existsSync(videoFile)) {
+            fs.copyFileSync(videoFile, targetVideoPath);
+        } else if (scene.image) {
+            const imagePath = path.isAbsolute(scene.image) ? scene.image : path.join(screenshotsDir, scene.image);
+            if (fs.existsSync(imagePath)) {
+                console.log(`[Bridge] Segment ${sceneIndexStr} not found. Animating static image: ${scene.image}`);
+                const animEffect = mapEffect(scene.effect);
+                animateScreenshot(imagePath, targetVideoPath, {
+                    effect: animEffect,
+                    durationSec: sceneDuration,
+                    width: sb.project?.width || 1080,
+                    height: sb.project?.height || 1920
+                });
+            } else {
+                console.warn(`[Bridge] Warning: Neither video segment nor screenshot found for scene: ${id}. A placeholder is needed.`);
+            }
+        } else {
+            console.warn(`[Bridge] Warning: No video segment or image found for scene: ${id}.`);
+        }
+
+        let ttsFile = path.join(shortmakerDir, 'tts', `${scene.id || `scene-${sceneIndexStr}`}.mp3`);
+        if (!fs.existsSync(ttsFile)) {
+            ttsFile = path.join(shortmakerDir, 'tts', `scene-${sceneIndexStr}.mp3`);
+        }
+        if (!fs.existsSync(ttsFile)) {
+            ttsFile = path.join(shortmakerDir, 'tts', `scene-${sceneIndexStr}.wav`);
+        }
+
+        const hasTts = fs.existsSync(ttsFile);
+
+        if (hasTts) {
+            const targetTtsFile = `dialogue-${sceneIndexStr}${path.extname(ttsFile)}`;
+            const targetTtsPath = path.join(mediaDir, targetTtsFile);
+            fs.copyFileSync(ttsFile, targetTtsPath);
+
+            const ttsDur = getMediaDuration(targetTtsPath);
+            if (ttsDur > 0) {
+                sceneDuration = ttsDur;
+            }
+
+            dialogue.push({
+                id: `dialogue-${sceneIndexStr}`,
+                source: `./media/${targetTtsFile}`,
+                sourceStart: 0,
+                duration: sceneDuration,
+                timelineStart: currentTimelineStart,
+                volume: 1.0,
+                fadeIn: 0.05,
+                fadeOut: 0.12,
+                subtitle: scene.speech || ""
+            });
+
+            duckingIntervals.push({
+                start: currentTimelineStart,
+                end: currentTimelineStart + sceneDuration
+            });
+        }
+
+        shots.push({
+            id: id,
+            source: `./media/${targetVideoFile}`,
+            sourceStart: 0,
+            duration: sceneDuration,
+            timelineStart: currentTimelineStart
+        });
+
+        if (scene.speech || scene.text || scene.overlay) {
+            captions.push({
+                id: `caption-${sceneIndexStr}`,
+                timelineStart: currentTimelineStart,
+                duration: sceneDuration,
+                text: scene.speech || scene.text || scene.overlay
+            });
+        }
+
+        currentTimelineStart += sceneDuration;
+    }
+
+    const edlConfig = {
+        project: {
+            width: sb.project?.width || 1080,
+            height: sb.project?.height || 1920,
+            fps: sb.project?.fps || 30,
+            duration: currentTimelineStart,
+            title: sb.project?.name || "ShortMaker Mixed Video",
+            kicker: sb.project?.framework || "AIDA Promo"
+        },
+        music: {
+            path: "./media/music.mp3",
+            start: sb.audio?.start || 0,
+            duration: currentTimelineStart,
+            volume: parseFloat(bgmVolume) || 0.2,
+            fadeIn: sb.audio?.fadeIn !== undefined ? sb.audio.fadeIn : 1.0,
+            fadeOut: sb.audio?.fadeOut !== undefined ? sb.audio.fadeOut : 2.0,
+            ducking: duckingIntervals
+        },
+        shots: shots,
+        dialogue: dialogue,
+        captions: captions,
+        style: {
+            flashColors: ["#f7f0cf", "#93ffd4", "#fff0b4", "#ffd28b"]
+        },
+        assets: {
+            gsap: "./gsap.min.js"
+        }
+    };
+
+    const edlPath = path.join(outDir, 'edl.json');
+    fs.writeFileSync(edlPath, JSON.stringify(edlConfig, null, 2), 'utf8');
+    console.log(`[Bridge] ✅ Successfully created EDL: ${edlPath}`);
+    console.log(`[Bridge] BGM source used: ${bgmSourceUsed}`);
+    console.log(`[Bridge] Total scenes: ${shots.length}, Duration: ${currentTimelineStart.toFixed(2)}s`);
+}
+
+module.exports = {
+    runBridge
+};
+
+if (require.main === module) {
+    const args = process.argv.slice(2);
+    const shortmakerDirArg = args.find(a => a.startsWith('--project-dir='))?.split('=')[1];
+    const outDirArg = args.find(a => a.startsWith('--out-dir='))?.split('=')[1];
+    const bgmVolumeArg = args.find(a => a.startsWith('--bgm-volume='))?.split('=')[1] || "0.2";
+
+    if (!shortmakerDirArg || !outDirArg) {
+        console.error('Usage: node scripts/shortmaker-bridge.js --project-dir=<path> --out-dir=<path> [--bgm-volume=0.2]');
+        process.exit(1);
+    }
+
+    runBridge({
+        shortmakerDir: path.resolve(shortmakerDirArg),
+        outDir: path.resolve(outDirArg),
+        bgmVolume: parseFloat(bgmVolumeArg)
+    }).catch(err => {
+        console.error(`[Bridge] Error: ${err.message}`);
+        process.exit(1);
+    });
+}