@opensassi/opencode 0.1.4 → 0.2.0

package/AGENTS.md

@@ -9,6 +9,7 @@ All skills, scripts, and tooling are delivered via the npm package.
 |---------|----------|
 | `asm-optimizer` | SIMD/assembly optimization framework |
 | `daily-evaluation` | Aggregate session evaluations into dashboards |
+| `demo-video` | Produce narrated demo videos with multi-language subtitles |
 | `git` | Rebase-based single-commit-per-session workflow |
 | `issue` | GitHub issue management |
 | `npm-optimizer` | Port an npm package to a C++ native addon |
@@ -23,8 +24,9 @@ All skills, scripts, and tooling are delivered via the npm package.
 ## Workflow
 
 1. `skill opensassi` — Load the bootstrap skill. It exposes the full skills-index as a reference table.
-2. Run `npx @opensassi/opencode <skill-name>` to load any sub-skill. The agent reads the output as the skill's full instructions.
-3. Use the skill's commands. Scripts are run via `npx @opensassi/opencode run <path>` or `npx @opensassi/opencode run --skill <name> <path>`.
+2. Run `npm run opencode -- <skill-name>` to load any sub-skill. The agent reads the output as the skill's full instructions.
+3. Use the skill's commands. Scripts are run via `npm run opencode -- run <path>` or `npm run opencode -- run --skill <name> <path>`.
+   - *Consumers of the published package use `npx @opensassi/opencode` instead of `npm run opencode --`.*
 
 ## Design Constraints
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opensassi/opencode",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "Agent skill harness for opencode — bootstrap, system-design, git workflow, profiling, and more",
   "type": "module",
   "bin": {
@@ -22,6 +22,7 @@
     "!**/*.spec.md"
   ],
   "scripts": {
+    "opencode": "node bin/opencode.js",
     "extract": "node scripts/extract-artifacts.js",
     "extract:file": "node scripts/extract-artifacts.js --file",
     "test-artifacts": "node scripts/test-artifacts.js",

package/skills/demo-video/SKILL.md

@@ -0,0 +1,264 @@
+---
+name: demo-video
+description: Produce narrated, edited demo videos from project outlines. Captures terminal TUI sessions via script(1), browser interactions via Playwright, then assembles clips with edge-tts narration and multi-language subtitles via ffmpeg.
+---
+
+# Skill: demo-video
+
+## Persona
+
+You are a **senior DevOps and multimedia automation engineer**. Your role is to produce polished, narrated demonstration videos of software projects — from a high-level outline through to a final MP4 file with multi-language subtitles. You automate every step: planning scenes, recording terminal TUI output, capturing browser interactions, generating text-to-speech narration, and assembling the final video with transitions and subtitles.
+
+You work **methodically** — always verify dependencies first, generate the scene file from an outline, record each scene independently, then assemble. You never produce a video without first checking the project's README, structure, and key commands.
+
+---
+
+## On Activation
+
+1. **Read project context** — Read the README, package.json, recent git log, and key source files to understand what the project does and what should be shown.
+2. **Check dependencies** — Run `setup.sh` to verify ffmpeg, edge-tts, and Playwright are available.
+3. **Check for existing scene file** — Look for `demo-scenes.json` in the project root. If it exists, ask whether to re-use, revise, or regenerate.
+4. **Report readiness** — Print the project name, a one-line summary, dependency status, and whether a scene file already exists.
+5. **List available commands** — Show the 3 workflow phases and 8 available scripts.
+
+---
+
+## Dependencies
+
+The host machine must have:
+
+| Tool | Install | Purpose |
+|------|---------|---------|
+| `ffmpeg ≥ 6.0` | `apt/brew/choco install ffmpeg` | Clip extraction, transitions, audio mixing, encoding |
+| `edge-tts` | `pip install edge-tts` | Text-to-speech narration (Microsoft Edge engine) |
+| `playwright` | `npx playwright install chromium` | Browser automation + HTML-to-video capture |
+
+Run `setup.sh` to check all three and print install guidance for any missing tools.
+
+---
+
+## Scene JSON Format
+
+The scene file (`demo-scenes.json`) is the single source of truth. Generate it from the project outline, then pass it to the `record` and `produce` phases.
+
+### Scene Types
+
+| Type | Purpose |
+|------|---------|
+| `terminal_command` | Shows a command being executed inside a terminal TUI |
+| `browser` | Opens a URL in Playwright, captures the viewport |
+| `narration_only` | Full-screen slide with bullet points and TTS |
+
+### Top-Level Structure
+
+```json
+{
+  "metadata": {
+    "title": "Demo Title",
+    "output_file": "demo-final.mp4",
+    "resolution": "1920x1080",
+    "frame_rate": 30
+  },
+  "languages": {
+    "en": { "voice": "en-US-AriaNeural" },
+    "zh": { "voice": "zh-CN-XiaoxiaoNeural" }
+  },
+  "scenes": [
+    { "id": 1, "type": "terminal_command", ... },
+    { "id": 2, "type": "browser", ... },
+    { "id": 3, "type": "narration_only", ... }
+  ]
+}
+```
+
+### Scene Fields
+
+**Common to all types:**
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `id` | integer | yes | Unique scene number |
+| `type` | string | yes | `terminal_command`, `browser`, or `narration_only` |
+| `narration` | object | yes | Map of language code → narration text (e.g. `{"en": "...", "zh": "..."}`) |
+| `transition` | string | no | `fade`, `wipe_left`, `wipe_right`, `none` (default `fade`) |
+| `transition_duration` | number | no | Transition length in seconds (default 0.5) |
+
+**`terminal_command`:**
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `command` | string | yes | Shell command to execute |
+| `cwd` | string | no | Working directory (default project root) |
+| `speed` | number | no | Replay speed multiplier (default 3, range 1-10) |
+| `duration` | number | no | Scene length in seconds (default: auto from command run time) |
+
+**`browser`:**
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `url` | string | yes | URL to open |
+| `duration` | number | yes | How long to show the browser (seconds) |
+| `actions` | array | no | List of `{type, selector}` actions (click, scroll, type) |
+
+**`narration_only`:**
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `bullets` | array | yes | Bullet point strings |
+| `duration` | number | yes | Slide duration in seconds |
+| `background_color` | string | no | CSS color (default `#1e1e2e`) |
+| `text_color` | string | no | CSS color (default `#cdd6f4`) |
+
+---
+
+## Workflow
+
+### Phase 1: Plan
+
+**Goal:** Generate `demo-scenes.json` from a high-level outline.
+
+1. Read the project's README, package.json, recent git log, and source layout.
+2. Draft a scene-by-scene outline. Each scene should show one aspect of the project.
+3. For each `terminal_command` scene, decide what command to run and what it will demonstrate.
+4. For each `browser` scene, decide what URL to open and what UI interaction to show.
+5. Write narration text in English for each scene.
+6. **Translate narration** into all target languages (the agent's own LLM capacity handles translation).
+7. Write the complete `demo-scenes.json` to disk.
+
+**Output:** `demo-scenes.json`
+
+### Phase 2: Record
+
+**Goal:** Capture one video clip per scene.
+
+For each scene in `demo-scenes.json`:
+
+#### Record: `terminal_command`
+
+1. Run the command with `script --timing` to capture authentic TUI output:
+   ```bash
+   script --timing=/tmp/demo/scene_N.timing \
+     --flush /tmp/demo/scene_N.output \
+     -c "cd <cwd> && <command>"
+   ```
+2. Generate an accelerated terminal replay HTML:
+   ```bash
+   npm run opencode -- run --skill demo-video render-terminal.cjs \
+     --timing /tmp/demo/scene_N.timing \
+     --output /tmp/demo/scene_N.output \
+     --command "<command>" \
+     --speed <speed> \
+     --html /tmp/demo/scene_N.html
+   ```
+3. Capture the HTML as a video clip via Playwright:
+   ```bash
+   npm run opencode -- run --skill demo-video capture-html.sh \
+     --html /tmp/demo/scene_N.html \
+     --duration <duration> \
+     --output /tmp/demo/clips/scene_N.mp4
+   ```
+
+#### Record: `browser`
+
+```bash
+npm run opencode -- run --skill demo-video capture-browser.sh \
+  --url "<url>" \
+  --actions '<json>' \
+  --duration <duration> \
+  --output /tmp/demo/clips/scene_N.mp4
+```
+
+#### Record: `narration_only`
+
+1. Generate an HTML slide:
+   ```bash
+   npm run opencode -- run --skill demo-video render-slide.cjs \
+     --title "<scene title>" \
+     --bullets '<json>' \
+     --background "#1e1e2e" \
+     --foreground "#cdd6f4" \
+     --output /tmp/demo/scene_N.html
+   ```
+2. Capture as video:
+   ```bash
+   npm run opencode -- run --skill demo-video capture-html.sh \
+     --html /tmp/demo/scene_N.html \
+     --duration <duration> \
+     --output /tmp/demo/clips/scene_N.mp4
+   ```
+
+**Output:** `/tmp/demo/clips/scene_1.mp4`, `scene_2.mp4`, ...
+
+### Phase 3: Produce
+
+**Goal:** Generate TTS audio, subtitle files, and assemble the final video.
+
+#### Step 1 — Generate TTS audio (English only)
+
+For each scene with non-empty English narration:
+```bash
+npm run opencode -- run --skill demo-video generate-tts.sh \
+  --text "<english narration text>" \
+  --voice en-US-AriaNeural \
+  --output /tmp/demo/audio/scene_N.mp3
+```
+
+#### Step 2 — Generate subtitle files (all languages)
+
+```bash
+npm run opencode -- run --skill demo-video generate-subs.cjs \
+  --scenes /tmp/demo/scenes.json \
+  --languages '["zh","es","de"]' \
+  --output-dir /tmp/demo/subs/
+```
+
+Each language produces `demo.{lang}.srt` with subtitle timing derived from the scene durations and narration text.
+
+#### Step 3 — Assemble final video
+
+```bash
+npm run opencode -- run --skill demo-video assemble.cjs \
+  --manifest /tmp/demo/manifest.json \
+  --output /tmp/demo/demo-final.mp4
+```
+
+The manifest is a JSON file listing all scene clips, transitions, and audio references. The assembly script:
+1. Pads or trims each clip to match its narration audio duration
+2. Applies crossfade transitions between consecutive clips
+3. Mixes narration audio into the video track
+4. Encodes as H.264 AAC in MP4 container
+
+**Output:** `demo-final.mp4` + `demo-final.zh.srt` + `demo-final.es.srt` + ...
+
+---
+
+## Script Reference
+
+All scripts are invoked via:
+```bash
+npm run opencode -- run --skill demo-video <script-name> [args...]
+```
+(Published consumers use `npx @opensassi/opencode run --skill demo-video <script-name> [args...]`)
+
+| Script | Purpose |
+|--------|---------|
+| `setup.sh` | Check ffmpeg, edge-tts, Playwright; print install guidance |
+| `render-terminal.cjs` | Convert `script --timing` output to accelerated terminal HTML replay |
+| `render-slide.cjs` | Generate narration HTML slide with styled bullet points |
+| `capture-html.sh` | Open HTML page in Playwright, record viewport as MP4 |
+| `capture-browser.sh` | Navigate to URL in Playwright with optional interactions, record as MP4 |
+| `generate-tts.sh` | Generate TTS MP3 via edge-tts from text |
+| `generate-subs.cjs` | Generate SRT subtitle files from multi-language scene narration |
+| `assemble.cjs` | Full ffmpeg assembly: concatenate clips, transitions, mix audio, encode |
+
+---
+
+## Design Principles
+
+- **Clips are independent** — Each scene is captured separately. A failed scene can be retried without re-recording the entire demo.
+- **Timing collapse** — LLM thinking time and command execution pauses are collapsed via the `speed` multiplier (default 3×). The visual shows the TUI replaying faster than real time.
+- **Subtitle-first for non-English** — One English audio track. Other languages get SRT subtitle files generated by the agent from translations. Languages with TTS support can optionally get full audio in a future enhancement.
+- **Agent translates** — The agent's own LLM capacity generates all non-English narration text during the Plan phase. No external translation API is required.
+- **Zero desktop recording** — No x11grab, no avfoundation, no screen noise. Terminal output is captured via `script --timing` and rendered as styled HTML. Browser content is captured directly via Playwright.
+- **Cross-platform by default** — Playwright works on Linux, macOS, and Windows. No platform-specific capture code. ffmpeg and edge-tts are available on all three.
+- **`--keep-raw`** — Pass `--keep-raw` to the assemble step to preserve intermediate clips, audio, and subtitle files for inspection or re-processing.

package/skills/demo-video/scripts/assemble.cjs

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+const fs = require('fs')
+const path = require('path')
+const { execSync } = require('child_process')
+
+function parseArgs() {
+  const args = {}
+  for (let i = 2; i < process.argv.length; i += 2) {
+    const key = process.argv[i].replace(/^--/, '')
+    args[key] = process.argv[i + 1]
+  }
+  if (!args.mode || !args.output) {
+    console.error('Usage: assemble.cjs --mode <video-only|audio-only|final> --manifest <json> --output <file> [--keep-raw]')
+    console.error('  --mode video-only  : concat scene clips, no audio')
+    console.error('  --mode audio-only  : concat TTS audio files sequentially')
+    console.error('  --mode final       : mix existing video_master + audio_master')
+    process.exit(1)
+  }
+  return args
+}
+
+function getDuration(file) {
+  try {
+    const out = execSync(
+      `ffprobe -v error -show_entries format=duration -of csv=p=0 "${file}"`,
+      { encoding: 'utf-8', timeout: 10000 }
+    ).trim()
+    return parseFloat(out) || 0
+  } catch { return 0 }
+}
+
+function assembleVideo(manifest, outputPath, keepRaw) {
+  const scenes = manifest.scenes || []
+  const workdir = path.dirname(path.resolve(outputPath))
+
+  // Pad/trim each clip to match target duration
+  const clipInfo = []
+  for (let i = 0; i < scenes.length; i++) {
+    const s = scenes[i]
+    if (!s.clip) { clipInfo.push(null); continue }
+    const clipDur = getDuration(s.clip)
+    const targetDur = s.duration || clipDur
+    const adjusted = path.join(workdir, `adjusted_${i}.mkv`)
+    const pad = targetDur - clipDur
+    if (pad > 0.1) {
+      execSync(`ffmpeg -y -i "${s.clip}" -filter:v "tpad=stop_mode=clone:stop_duration=${pad}" -an "${adjusted}"`, { stdio: 'ignore', timeout: 60000 })
+    } else if (pad < -0.1) {
+      execSync(`ffmpeg -y -i "${s.clip}" -filter:v "setpts=${(targetDur / clipDur).toFixed(3)}*PTS" -an "${adjusted}"`, { stdio: 'ignore', timeout: 60000 })
+    } else {
+      fs.copyFileSync(s.clip, adjusted)
+    }
+    clipInfo.push({ clip: adjusted, duration: targetDur })
+  }
+
+  const valid = clipInfo.filter(c => c !== null)
+  if (valid.length === 0) throw new Error('No valid clips')
+
+  const raw = path.join(workdir, 'video_raw.mkv')
+  const inputArgs = valid.map(c => `-i "${c.clip}"`).join(' ')
+  const labels = valid.map((_, i) => `[${i}:v]`).join('')
+  execSync(
+    `ffmpeg -y ${inputArgs} -filter_complex "${labels}concat=n=${valid.length}:v=1:a=0[out]" -map "[out]" -c:v libx264 -preset veryfast -crf 28 "${raw}"`,
+    { stdio: 'ignore', timeout: 120000 }
+  )
+
+  const outResolved = path.resolve(outputPath)
+  execSync(`ffmpeg -y -i "${raw}" -c:v libx264 -preset medium -crf 18 "${outResolved}"`, { stdio: 'ignore', timeout: 120000 })
+  console.log(`Video master: ${outResolved}`)
+
+  if (!keepRaw) {
+    for (const c of valid) { try { fs.unlinkSync(c.clip) } catch {} }
+    try { fs.unlinkSync(raw) } catch {}
+    try { fs.unlinkSync(concatList) } catch {}
+  }
+}
+
+function assembleAudio(manifest, outputPath, keepRaw) {
+  const scenes = manifest.scenes || []
+  const workdir = path.dirname(path.resolve(outputPath))
+  const audioFiles = scenes.map(s => s.audio).filter(Boolean)
+
+  if (audioFiles.length === 0) throw new Error('No audio files in manifest')
+
+  const concatList = path.join(workdir, 'audio_concat.txt')
+  const lines = audioFiles.map(f => `file '${f}'`)
+  fs.writeFileSync(concatList, lines.join('\n'), 'utf-8')
+
+  const outResolved = path.resolve(outputPath)
+  execSync(`ffmpeg -y -f concat -safe 0 -i "${concatList}" -c:a aac -b:a 128k "${outResolved}"`, { stdio: 'ignore', timeout: 120000 })
+  console.log(`Audio master: ${outResolved}`)
+
+  if (!keepRaw) {
+    try { fs.unlinkSync(concatList) } catch {}
+  }
+}
+
+function assembleFinal(args) {
+  const videoPath = path.resolve(args.video)
+  const audioPath = path.resolve(args.audio)
+  const outputPath = path.resolve(args.output)
+  const keepRaw = args['keep-raw'] === 'true'
+
+  if (!fs.existsSync(videoPath)) throw new Error(`Video not found: ${videoPath}`)
+  if (!fs.existsSync(audioPath)) throw new Error(`Audio not found: ${audioPath}`)
+
+  const vDur = getDuration(videoPath)
+  const aDur = getDuration(audioPath)
+  const diff = Math.abs(vDur - aDur)
+
+  if (diff > 0.5) {
+    throw new Error(`Video (${vDur.toFixed(2)}s) and audio (${aDur.toFixed(2)}s) mismatch by ${diff.toFixed(2)}s`)
+  }
+
+  const workdir = path.dirname(outputPath)
+  const mixed = path.join(workdir, 'mixed.mkv')
+  execSync(
+    `ffmpeg -y -i "${videoPath}" -i "${audioPath}" -c:v copy -c:a aac -b:a 128k -shortest "${mixed}"`,
+    { stdio: 'ignore', timeout: 120000 }
+  )
+
+  const outResolved = path.resolve(outputPath)
+  execSync(
+    `ffmpeg -y -i "${mixed}" -c copy -movflags +faststart "${outResolved}"`,
+    { stdio: 'ignore', timeout: 60000 }
+  )
+  console.log(`Final: ${outResolved}`)
+
+  if (!keepRaw) {
+    try { fs.unlinkSync(mixed) } catch {}
+  }
+}
+
+function main() {
+  const args = parseArgs()
+  const mode = args.mode
+
+  if (mode === 'video-only') {
+    const manifest = JSON.parse(fs.readFileSync(path.resolve(args.manifest), 'utf-8'))
+    assembleVideo(manifest, args.output, args['keep-raw'] === 'true')
+  } else if (mode === 'audio-only') {
+    const manifest = JSON.parse(fs.readFileSync(path.resolve(args.manifest), 'utf-8'))
+    assembleAudio(manifest, args.output, args['keep-raw'] === 'true')
+  } else if (mode === 'final') {
+    assembleFinal(args)
+  } else {
+    console.error(`Unknown mode: ${mode}`)
+    process.exit(1)
+  }
+}
+
+if (require.main === module) main()
+module.exports = { assembleVideo, assembleAudio, assembleFinal, getDuration }

package/skills/demo-video/scripts/capture-browser.sh

@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  echo "Usage: capture-browser.sh --url <url> [--actions <json>] --duration <sec> --output <file>"
+  exit 1
+}
+
+URL=""
+ACTIONS="[]"
+DURATION=""
+OUTPUT=""
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --url) URL="$2"; shift 2 ;;
+    --actions) ACTIONS="$2"; shift 2 ;;
+    --duration) DURATION="$2"; shift 2 ;;
+    --output) OUTPUT="$2"; shift 2 ;;
+    *) echo "Unknown option: $1"; usage ;;
+  esac
+done
+
+[ -z "$URL" ] || [ -z "$DURATION" ] || [ -z "$OUTPUT" ] && usage
+
+mkdir -p "$(dirname "$OUTPUT")"
+
+node -e "
+const { chromium } = require('playwright');
+const actions = ${ACTIONS};
+(async () => {
+  const browser = await chromium.launch({ headless: true });
+  const context = await browser.newContext({
+    viewport: { width: 1920, height: 1080 },
+    recordVideo: { dir: '$(dirname "$OUTPUT")', size: { width: 1920, height: 1080 } }
+  });
+  const page = await context.newPage();
+  const startMs = Date.now();
+  await page.goto('${URL}', { waitUntil: 'networkidle' });
+
+  if (actions.length > 0) {
+    for (const action of actions) {
+      const el = action.selector ? await page.\$(action.selector) : null;
+      if (!el) continue;
+      if (action.type === 'click') await el.click();
+      else if (action.type === 'type' && action.text) await el.fill(action.text);
+      else if (action.type === 'scroll') await page.evaluate((s) => window.scrollBy(0, s), action.y || 500);
+      await page.waitForTimeout(500);
+    }
+  }
+
+  const elapsed = (Date.now() - startMs) / 1000;
+  const remaining = Math.max(0, ${DURATION} - elapsed);
+  await page.waitForTimeout(remaining * 1000);
+  await context.close();
+  await browser.close();
+  const videoPath = await page.video().path();
+  require('fs').renameSync(videoPath, '${OUTPUT}');
+  console.log('Captured: ${OUTPUT}');
+})();
+" || {
+  echo "FAILED: Could not capture $URL"
+  exit 1
+}

package/skills/demo-video/scripts/capture-html.sh

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  echo "Usage: capture-html.sh --html <file> --duration <sec> --output <file>"
+  exit 1
+}
+
+HTML=""
+DURATION=""
+OUTPUT=""
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --html) HTML="$2"; shift 2 ;;
+    --duration) DURATION="$2"; shift 2 ;;
+    --output) OUTPUT="$2"; shift 2 ;;
+    *) echo "Unknown option: $1"; usage ;;
+  esac
+done
+
+[ -z "$HTML" ] || [ -z "$DURATION" ] || [ -z "$OUTPUT" ] && usage
+[ ! -f "$HTML" ] && echo "HTML file not found: $HTML" && exit 1
+
+mkdir -p "$(dirname "$OUTPUT")"
+
+node -e "
+const { chromium } = require('playwright');
+const path = require('path');
+const fs = require('fs');
+(async () => {
+  const browser = await chromium.launch({ headless: true });
+  const context = await browser.newContext({
+    viewport: { width: 1920, height: 1080 },
+    deviceScaleFactor: 1,
+    recordVideo: { dir: '$(dirname "$OUTPUT")', size: { width: 1920, height: 1080 } }
+  });
+  const page = await context.newPage();
+  await page.goto('file://${HTML}');
+  await page.waitForTimeout(${DURATION} * 1000);
+  await context.close();
+  await browser.close();
+  const videoPath = await page.video().path();
+  const outPath = path.resolve('${OUTPUT}');
+  fs.renameSync(videoPath, outPath);
+  console.log('Captured: ' + outPath);
+})().catch(e => { console.error('FAILED:', e.message); process.exit(1); });
+"

package/skills/demo-video/scripts/generate-subs.cjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+const fs = require('fs')
+const path = require('path')
+
+function parseArgs() {
+  const args = {}
+  for (let i = 2; i < process.argv.length; i += 2) {
+    const key = process.argv[i].replace(/^--/, '')
+    args[key] = process.argv[i + 1]
+  }
+  if (!args.scenes || !args.languages || !args['output-dir']) {
+    console.error('Usage: generate-subs.js --scenes <json> --languages <json> --output-dir <dir>')
+    process.exit(1)
+  }
+  return args
+}
+
+function formatTime(seconds) {
+  const h = Math.floor(seconds / 3600)
+  const m = Math.floor((seconds % 3600) / 60)
+  const s = seconds % 60
+  const cs = Math.floor((s % 1) * 100)
+  const si = Math.floor(s)
+  return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}:${String(si).padStart(2, '0')}.${String(cs).padStart(2, '0')}`
+}
+
+function generateSrt(scenes, lang) {
+  const lines = []
+  let cueIdx = 1
+  let currentTime = 0
+
+  for (const scene of scenes) {
+    const text = (scene.narration && scene.narration[lang]) || (scene.narration && scene.narration.en) || ''
+    const duration = scene.duration || 5
+    if (!text) {
+      currentTime += duration
+      continue
+    }
+    const start = currentTime
+    currentTime += duration
+    lines.push(String(cueIdx))
+    lines.push(`${formatTime(start)} --> ${formatTime(currentTime)}`)
+    lines.push(text)
+    lines.push('')
+    cueIdx++
+  }
+
+  return lines.join('\n')
+}
+
+function main() {
+  const args = parseArgs()
+  const scenesPath = path.resolve(args.scenes)
+  const languages = JSON.parse(args.languages)
+  const outputDir = path.resolve(args['output-dir'])
+
+  if (!fs.existsSync(scenesPath)) {
+    console.error(`Scenes file not found: ${scenesPath}`)
+    process.exit(1)
+  }
+
+  const scenesData = JSON.parse(fs.readFileSync(scenesPath, 'utf-8'))
+  const scenes = scenesData.scenes || []
+  fs.mkdirSync(outputDir, { recursive: true })
+
+  for (const lang of languages) {
+    const srt = generateSrt(scenes, lang)
+    const outPath = path.join(outputDir, `demo.${lang}.srt`)
+    fs.writeFileSync(outPath, srt, 'utf-8')
+    console.log(`Wrote: ${outPath}`)
+  }
+}
+
+if (require.main === module) main()
+module.exports = { generateSrt }

package/skills/demo-video/scripts/generate-tts.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  echo "Usage: generate-tts.sh --text <text> --voice <name> --output <file>"
+  exit 1
+}
+
+TEXT=""
+VOICE="en-US-AriaNeural"
+OUTPUT=""
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --text) TEXT="$2"; shift 2 ;;
+    --voice) VOICE="$2"; shift 2 ;;
+    --output) OUTPUT="$2"; shift 2 ;;
+    *) echo "Unknown option: $1"; usage ;;
+  esac
+done
+
+[ -z "$TEXT" ] || [ -z "$OUTPUT" ] && usage
+
+mkdir -p "$(dirname "$OUTPUT")"
+
+python3 -m edge_tts --voice "$VOICE" --text "$TEXT" --write-media "$OUTPUT"
+
+echo "Generated: $OUTPUT"