Document To Narration

# TTS model files (too large for git)
tts/model/*
!tts/model/.gitkeep

# Python virtual environment
tts/.venv/

# Output directories
output/

# Whisper installation
whisper.cpp/

# Temporary files
*.pyc
__pycache__/
tmp/

{
  "_meta": {
    "description": "Rules for adapting written text to spoken delivery",
    "version": "1.0"
  },
  "replacements": {
    "abbreviations": {
      "e.g.": "for example",
      "i.e.": "that is",
      "etc.": "and so on",
      "vs.": "versus",
      "vs": "versus",
      "w/": "with",
      "b/c": "because",
      "w/o": "without",
      "approx.": "approximately",
      "esp.": "especially",
      "incl.": "including"
    },
    "symbols": {
      "&": "and",
      "%": "percent",
      "+": "plus",
      "=": "equals",
      "~": "approximately"
    }
  },
  "punctuation_patterns": {
    "parenthetical_to_dash": {
      "description": "Convert parenthetical asides to em-dashes or separate sentences",
      "example_before": "The tool (which was available to both) produced different results.",
      "example_after": "The tool — which was available to both — produced different results."
    },
    "semicolon_to_period": {
      "description": "Break semicolon-joined clauses into separate sentences",
      "example_before": "The first person found the floor; the second discovered the ceiling.",
      "example_after": "The first person found the floor. The second discovered the ceiling."
    },
    "ellipsis_handling": {
      "description": "Replace ellipsis with period or natural pause",
      "example_before": "And then... it clicked.",
      "example_after": "And then it clicked."
    }
  },
  "sentence_structure": {
    "max_clause_depth": 2,
    "split_triggers": [
      "which, in turn,",
      "although it should be noted that",
      "despite the fact that",
      "in addition to the fact that",
      "notwithstanding the possibility that"
    ]
  },
  "emphasis_handling": {
    "italics": {
      "description": "Context determines stress; often no change needed",
      "note": "TTS handles emphasis through sentence context"
    },
    "bold": {
      "description": "Usually structural emphasis; may need spoken equivalent",
      "note": "Consider adding 'importantly' or similar if emphasis is critical"
    },
    "ALL_CAPS": {
      "description": "Strong emphasis; preserve meaning through word choice",
      "note": "Convert to lowercase but ensure context conveys emphasis"
    }
  },
  "preserve_patterns": [
    "rhetorical_questions",
    "deliberate_repetition",
    "parallel_structure",
    "author_voice_phrases",
    "memorable_formulations"
  ],
  "transition_phrases": {
    "section_start": [
      "Now,",
      "Here's where things get interesting:",
      "Let's look at",
      "Consider this:"
    ],
    "returning_to_point": [
      "Back to our main question:",
      "Returning to the point:",
      "This brings us back to:"
    ],
    "contrast_pivot": [
      "But here's the thing:",
      "However,",
      "On the other hand,"
    ],
    "building": [
      "And this connects to",
      "Building on this,",
      "Taking this further,"
    ],
    "conclusion": [
      "So what does this mean?",
      "The key takeaway is:",
      "In the end,"
    ]
  }
}

#!/usr/bin/env python3
"""
extract-scene-boundaries.py - Extract scene timing boundaries from transcript.

After generating audio with narrate-full.py and transcribing with transcribe-full.py,
this script finds where each scene starts in the audio by matching the opening
words of each scene text file against the transcript.

Usage:
    python extract-scene-boundaries.py ./narration/scenes/ ./narration/full-narration.json

    # Output as JSON for programmatic use
    python extract-scene-boundaries.py ./narration/scenes/ ./narration/full-narration.json --json

    # Output TypeScript code for Video.tsx
    python extract-scene-boundaries.py ./narration/scenes/ ./narration/full-narration.json --typescript
"""
import argparse
import json
import re
import sys
from pathlib import Path


def load_transcript(json_path: Path) -> list[dict]:
    """Load word-level timestamps from transcript JSON."""
    with open(json_path, "r", encoding="utf-8") as f:
        data = json.load(f)

    words = []
    for seg in data.get("segments", []):
        for w in seg.get("words", []):
            words.append({
                "word": w["word"].strip(),
                "start": w["start"],
                "end": w["end"],
            })

    return words


def get_scene_opening_phrases(scenes_dir: Path) -> list[tuple[str, str]]:
    """Get opening phrase from each scene file. Returns list of (filename, phrase)."""
    scene_files = sorted(scenes_dir.glob("*.txt"))
    phrases = []

    for f in scene_files:
        text = f.read_text(encoding="utf-8").strip()
        # Get first ~5 words as opening phrase
        words = text.split()[:5]
        phrase = " ".join(words)
        phrases.append((f.stem, phrase))

    return phrases


def normalize_word(word: str) -> str:
    """Normalize word for matching (lowercase, remove punctuation)."""
    return re.sub(r"[^\w]", "", word.lower())


def find_phrase_in_transcript(phrase: str, words: list[dict], start_from: int = 0) -> float | None:
    """Find where a phrase starts in the transcript. Returns start time or None."""
    phrase_words = phrase.split()
    phrase_normalized = [normalize_word(w) for w in phrase_words]

    # Search through transcript
    for i in range(start_from, len(words) - len(phrase_normalized) + 1):
        match = True
        for j, pw in enumerate(phrase_normalized):
            transcript_word = normalize_word(words[i + j]["word"])
            # Allow partial match (phrase word is prefix of transcript word)
            if not transcript_word.startswith(pw[:3]):  # Match at least first 3 chars
                match = False
                break

        if match:
            return words[i]["start"]

    return None


def extract_boundaries(scenes_dir: Path, transcript_path: Path) -> list[dict]:
    """Extract scene boundaries from transcript."""
    words = load_transcript(transcript_path)
    phrases = get_scene_opening_phrases(scenes_dir)

    if not words:
        print("Error: No words found in transcript", file=sys.stderr)
        sys.exit(1)

    if not phrases:
        print("Error: No scene files found", file=sys.stderr)
        sys.exit(1)

    boundaries = []
    last_end = 0
    search_from = 0

    for i, (slug, phrase) in enumerate(phrases):
        start_time = find_phrase_in_transcript(phrase, words, search_from)

        if start_time is None:
            print(f"Warning: Could not find scene '{slug}' starting with '{phrase}'", file=sys.stderr)
            # Use last known position
            start_time = last_end
        else:
            # Update search position to avoid finding same phrase twice
            search_from = next(
                (j for j, w in enumerate(words) if w["start"] >= start_time + 1),
                search_from
            )

        boundaries.append({
            "number": i + 1,
            "slug": slug,
            "start_seconds": start_time,
            "opening_phrase": phrase,
        })

        last_end = start_time

    # Calculate durations
    total_duration = words[-1]["end"] if words else 0

    for i, b in enumerate(boundaries):
        if i + 1 < len(boundaries):
            b["duration_seconds"] = round(boundaries[i + 1]["start_seconds"] - b["start_seconds"], 2)
        else:
            b["duration_seconds"] = round(total_duration - b["start_seconds"], 2)

    return boundaries


def format_table(boundaries: list[dict], total_duration: float) -> str:
    """Format boundaries as readable table."""
    lines = [
        "Scene Boundaries",
        "=" * 60,
        f"{'#':<4} {'Slug':<30} {'Start':>8} {'Duration':>10}",
        "-" * 60,
    ]

    for b in boundaries:
        lines.append(
            f"{b['number']:<4} {b['slug']:<30} {b['start_seconds']:>7.2f}s {b['duration_seconds']:>9.2f}s"
        )

    lines.append("-" * 60)
    lines.append(f"{'Total':<35} {total_duration:>18.2f}s")

    return "\n".join(lines)


def format_json(boundaries: list[dict]) -> str:
    """Format boundaries as JSON."""
    return json.dumps(boundaries, indent=2)


def format_typescript(boundaries: list[dict]) -> str:
    """Format boundaries as TypeScript for Video.tsx."""
    lines = [
        "// Scene timing data (at 30fps)",
        "// Timings extracted from full-narration.wav transcript",
        "const FPS = 30;",
        "const scenes = [",
    ]

    for b in boundaries:
        # Convert slug to component name
        parts = b["slug"].split("-")
        # Handle numbered prefix (e.g., "01-kitchen-opening" -> "Scene01KitchenOpening")
        if parts[0].isdigit():
            num = parts[0]
            name_parts = parts[1:]
        else:
            num = str(b["number"]).zfill(2)
            name_parts = parts

        component_name = f"Scene{num}{''.join(p.title() for p in name_parts)}"

        lines.append(f"  {{")
        lines.append(f"    number: {b['number']},")
        lines.append(f"    slug: '{'-'.join(name_parts)}',")
        lines.append(f"    durationSeconds: {b['duration_seconds']},  // {b['start_seconds']:.2f}s - {b['start_seconds'] + b['duration_seconds']:.2f}s")
        lines.append(f"    component: {component_name},")
        lines.append(f"  }},")

    lines.append("];")

    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(
        description="Extract scene timing boundaries from transcript",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
    python extract-scene-boundaries.py ./narration/scenes/ ./narration/full-narration.json
    python extract-scene-boundaries.py ./narration/scenes/ ./narration/full-narration.json --json
    python extract-scene-boundaries.py ./narration/scenes/ ./narration/full-narration.json --typescript
        """,
    )
    parser.add_argument(
        "scenes_dir",
        type=Path,
        help="Directory containing scene .txt files",
    )
    parser.add_argument(
        "transcript",
        type=Path,
        help="Path to transcript JSON file (from transcribe-full.py)",
    )
    parser.add_argument(
        "--json",
        action="store_true",
        help="Output as JSON",
    )
    parser.add_argument(
        "--typescript",
        action="store_true",
        help="Output as TypeScript for Video.tsx",
    )
    args = parser.parse_args()

    scenes_dir = args.scenes_dir.resolve()
    transcript_path = args.transcript.resolve()

    if not scenes_dir.exists():
        print(f"Error: Scenes directory not found: {scenes_dir}", file=sys.stderr)
        sys.exit(1)

    if not transcript_path.exists():
        print(f"Error: Transcript not found: {transcript_path}", file=sys.stderr)
        sys.exit(1)

    # Extract boundaries
    boundaries = extract_boundaries(scenes_dir, transcript_path)

    # Calculate total
    total_duration = sum(b["duration_seconds"] for b in boundaries)

    # Output
    if args.json:
        print(format_json(boundaries))
    elif args.typescript:
        print(format_typescript(boundaries))
    else:
        print(format_table(boundaries, total_duration))


if __name__ == "__main__":
    main()

#!/usr/bin/env -S deno run --allow-read --allow-write --allow-run --allow-env

/**
 * full-pipeline.ts
 *
 * Orchestrate the complete document-to-narration pipeline:
 * 1. Split document into scenes
 * 2. Generate TTS audio for each scene
 * 3. Transcribe audio for word-level timing
 *
 * Usage:
 *   deno run -A scripts/full-pipeline.ts input.md --output ./output/project-name/
 *   deno run -A scripts/full-pipeline.ts input.md --output ./output/ --skip-tts
 *   deno run -A scripts/full-pipeline.ts input.md --output ./output/ --by-headings
 */

import { dirname, fromFileUrl, join } from 'https://deno.land/std@0.208.0/path/mod.ts';

// ============================================================================
// Configuration
// ============================================================================

const SCRIPT_DIR = dirname(fromFileUrl(import.meta.url));
const SKILL_DIR = join(SCRIPT_DIR, '..');
const TTS_DIR = join(SKILL_DIR, 'tts');

// ============================================================================
// Utilities
// ============================================================================

async function runCommand(
  cmd: string,
  args: string[],
  options: { cwd?: string; env?: Record<string, string> } = {}
): Promise<{ success: boolean; stdout: string; stderr: string }> {
  const command = new Deno.Command(cmd, {
    args,
    cwd: options.cwd,
    env: options.env,
    stdout: 'piped',
    stderr: 'piped',
  });

  const result = await command.output();
  return {
    success: result.success,
    stdout: new TextDecoder().decode(result.stdout),
    stderr: new TextDecoder().decode(result.stderr),
  };
}

async function fileExists(path: string): Promise<boolean> {
  try {
    await Deno.stat(path);
    return true;
  } catch {
    return false;
  }
}

// ============================================================================
// Pipeline Steps
// ============================================================================

async function splitDocument(
  inputFile: string,
  outputDir: string,
  byHeadings: boolean,
  boundariesFile?: string
): Promise<boolean> {
  console.log('\n' + '='.repeat(60));
  console.log('STEP 1: Splitting document into scenes');
  console.log('='.repeat(60));

  const splitScript = join(SCRIPT_DIR, 'split-to-scenes.ts');
  const args = [
    'run',
    '--allow-read',
    '--allow-write',
    splitScript,
    inputFile,
    '--output',
    outputDir,
  ];

  if (boundariesFile) {
    args.push('--boundaries', boundariesFile);
  } else if (byHeadings) {
    args.push('--by-headings');
  } else {
    // Default to by-headings if no boundaries specified
    console.log('  Using default: splitting by H2 headings');
    args.push('--by-headings');
  }

  const result = await runCommand('deno', args);

  if (result.stdout) console.log(result.stdout);
  if (result.stderr) console.error(result.stderr);

  return result.success;
}

async function generateAudio(outputDir: string, force: boolean): Promise<boolean> {
  console.log('\n' + '='.repeat(60));
  console.log('STEP 2: Generating TTS audio');
  console.log('='.repeat(60));

  const scenesDir = join(outputDir, 'scenes');
  const narrateScript = join(SCRIPT_DIR, 'narrate-scenes.py');

  // Check for Python venv
  const venvPython = join(TTS_DIR, '.venv', 'bin', 'python');
  const hasPythonVenv = await fileExists(venvPython);

  let pythonCmd: string;
  if (hasPythonVenv) {
    pythonCmd = venvPython;
    console.log(`  Using venv Python: ${venvPython}`);
  } else {
    console.log('  Warning: No venv found at tts/.venv');
    console.log('  Trying system Python...');
    pythonCmd = 'python3';
  }

  const args = [narrateScript, scenesDir];
  if (force) {
    args.push('--force');
  }

  const result = await runCommand(pythonCmd, args);

  if (result.stdout) console.log(result.stdout);
  if (result.stderr) console.error(result.stderr);

  return result.success;
}

async function transcribeAudio(
  outputDir: string,
  whisperPath: string,
  model: string,
  force: boolean
): Promise<boolean> {
  console.log('\n' + '='.repeat(60));
  console.log('STEP 3: Transcribing audio for word-level timing');
  console.log('='.repeat(60));

  const scenesDir = join(outputDir, 'scenes');
  const transcribeScript = join(SCRIPT_DIR, 'transcribe-scenes.ts');

  const args = [
    'run',
    '--allow-read',
    '--allow-write',
    '--allow-run',
    transcribeScript,
    scenesDir,
    '--whisper-path',
    whisperPath,
    '--model',
    model,
  ];

  if (force) {
    args.push('--force');
  }

  const result = await runCommand('deno', args);

  if (result.stdout) console.log(result.stdout);
  if (result.stderr) console.error(result.stderr);

  return result.success;
}

// ============================================================================
// Main
// ============================================================================

function printHelp() {
  console.log(`
full-pipeline.ts - Complete document-to-narration pipeline

USAGE:
  deno run -A scripts/full-pipeline.ts <input.md> --output <dir> [options]

OPTIONS:
  --output <dir>           Output directory (required)
  --by-headings            Split by H2 headings (default if no boundaries)
  --boundaries <file>      Use agent-specified scene boundaries
  --skip-tts               Skip audio generation
  --skip-transcribe        Skip Whisper transcription
  --force                  Force regeneration of all files
  --whisper-path <dir>     Path to whisper.cpp (default: ./whisper.cpp)
  --whisper-model <name>   Whisper model (default: medium)
  --help, -h               Show this help

PREREQUISITES:
  1. Python venv at tts/.venv with requirements installed
  2. whisper.cpp installed with model downloaded

EXAMPLE:
  # Full pipeline with default settings
  deno run -A scripts/full-pipeline.ts essay.md --output ./output/my-essay/

  # Split only (no audio)
  deno run -A scripts/full-pipeline.ts essay.md --output ./output/ --skip-tts --skip-transcribe

  # With custom whisper settings
  deno run -A scripts/full-pipeline.ts essay.md --output ./output/ --whisper-model large-v3-turbo

PIPELINE:
  1. Split document into scene .txt files
  2. Generate .wav audio for each scene (TTS)
  3. Transcribe .wav to .vtt with word-level timing
  4. Update manifest.json with complete data
`);
}

async function main() {
  const args = Deno.args;

  if (args.includes('--help') || args.includes('-h') || args.length === 0) {
    printHelp();
    Deno.exit(0);
  }

  // Parse arguments
  const inputFile = args.find((a) => !a.startsWith('--'));
  const byHeadings = args.includes('--by-headings');
  const skipTTS = args.includes('--skip-tts');
  const skipTranscribe = args.includes('--skip-transcribe');
  const force = args.includes('--force');

  const outputIdx = args.indexOf('--output');
  const outputDir = outputIdx >= 0 ? args[outputIdx + 1] : null;

  const boundariesIdx = args.indexOf('--boundaries');
  const boundariesFile = boundariesIdx >= 0 ? args[boundariesIdx + 1] : undefined;

  const whisperPathIdx = args.indexOf('--whisper-path');
  const whisperPath = whisperPathIdx >= 0 ? args[whisperPathIdx + 1] : './whisper.cpp';

  const whisperModelIdx = args.indexOf('--whisper-model');
  const whisperModel = whisperModelIdx >= 0 ? args[whisperModelIdx + 1] : 'medium';

  // Validate
  if (!inputFile) {
    console.error('Error: No input file specified');
    Deno.exit(1);
  }

  if (!outputDir) {
    console.error('Error: --output directory required');
    Deno.exit(1);
  }

  if (!(await fileExists(inputFile))) {
    console.error(`Error: Input file not found: ${inputFile}`);
    Deno.exit(1);
  }

  // Create output directory
  await Deno.mkdir(outputDir, { recursive: true });

  console.log('Document to Narration Pipeline');
  console.log('='.repeat(60));
  console.log(`Input: ${inputFile}`);
  console.log(`Output: ${outputDir}`);
  console.log(`Skip TTS: ${skipTTS}`);
  console.log(`Skip Transcribe: ${skipTranscribe}`);

  // Step 1: Split document
  const splitSuccess = await splitDocument(inputFile, outputDir, byHeadings, boundariesFile);
  if (!splitSuccess) {
    console.error('\nError: Document splitting failed');
    Deno.exit(1);
  }

  // Step 2: Generate audio
  if (!skipTTS) {
    const audioSuccess = await generateAudio(outputDir, force);
    if (!audioSuccess) {
      console.error('\nWarning: Audio generation had errors');
      // Continue anyway - some files may have succeeded
    }
  } else {
    console.log('\n[Skipping TTS audio generation]');
  }

  // Step 3: Transcribe
  if (!skipTTS && !skipTranscribe) {
    const transcribeSuccess = await transcribeAudio(outputDir, whisperPath, whisperModel, force);
    if (!transcribeSuccess) {
      console.error('\nWarning: Transcription had errors');
    }
  } else if (skipTranscribe) {
    console.log('\n[Skipping Whisper transcription]');
  }

  // Summary
  console.log('\n' + '='.repeat(60));
  console.log('PIPELINE COMPLETE');
  console.log('='.repeat(60));
  console.log(`Output directory: ${outputDir}`);
  console.log(`\nGenerated files:`);

  const scenesDir = join(outputDir, 'scenes');
  if (await fileExists(scenesDir)) {
    for await (const entry of Deno.readDir(scenesDir)) {
      console.log(`  ${entry.name}`);
    }
  }

  const manifestPath = join(outputDir, 'manifest.json');
  if (await fileExists(manifestPath)) {
    console.log(`\nManifest: ${manifestPath}`);
  }
}

main();

#!/usr/bin/env python3
"""
narrate-full.py - Generate a single TTS audio file from all scene files.

Combines all scene .txt files and generates a single consistent audio file,
avoiding volume inconsistencies that occur when concatenating separately
generated audio files.

Usage:
    python narrate-full.py ./output/scenes/
    python narrate-full.py ./output/scenes/ --force
    python narrate-full.py ./output/scenes/ --speaker other_voice
"""
import argparse
import json
import sys
from pathlib import Path

import soundfile as sf
import torch
from qwen_tts import Qwen3TTSModel


# Directory setup (relative to script location)
SCRIPT_DIR = Path(__file__).parent.resolve()
SKILL_DIR = SCRIPT_DIR.parent
MODEL_DIR = SKILL_DIR / "tts" / "model"

# Default speaker name (from fine-tuning)
DEFAULT_SPEAKER = "jwynia"


def load_model():
    """Load the fine-tuned TTS model."""
    print("Loading TTS model...")
    print(f"  Model path: {MODEL_DIR}")

    if not MODEL_DIR.exists():
        print(f"Error: Model directory not found at {MODEL_DIR}")
        print("Make sure the model has been moved from inbox/portable-narrator/model/")
        sys.exit(1)

    # Determine device
    if torch.backends.mps.is_available():
        device = "mps"
    elif torch.cuda.is_available():
        device = "cuda"
    else:
        device = "cpu"

    print(f"  Device: {device}")

    tts = Qwen3TTSModel.from_pretrained(
        str(MODEL_DIR),
        device_map=device,
        dtype=torch.float32,
        attn_implementation="sdpa",
    )

    print("Model loaded!\n")
    return tts


def find_scene_files(scenes_dir: Path) -> list[Path]:
    """Find all .txt scene files in the directory."""
    files = list(scenes_dir.glob("*.txt"))
    # Sort by scene number (assumes NN-slug.txt format)
    files.sort(key=lambda f: f.name)
    return files


def combine_scene_texts(scene_files: list[Path]) -> str:
    """Combine all scene texts into a single string with paragraph breaks."""
    texts = []
    for f in scene_files:
        text = f.read_text(encoding="utf-8").strip()
        if text:
            texts.append(text)
            print(f"  Added: {f.name} ({len(text.split())} words)")

    # Join with double newline for natural pause between scenes
    combined = "\n\n".join(texts)
    total_words = len(combined.split())
    print(f"\nCombined: {len(texts)} scenes, {total_words} words total")

    return combined


def narrate_text(tts, text: str, output_path: Path, speaker: str) -> dict | None:
    """Generate speech for the combined text. Returns metadata or None on error."""
    print(f"\nGenerating speech for {len(text.split())} words...")
    print("(This may take a few minutes for longer texts)")

    try:
        wavs, sr = tts.generate_custom_voice(
            text=text,
            speaker=speaker,
        )
    except Exception as e:
        print(f"Error generating speech: {e}")
        return None

    # Save output
    sf.write(str(output_path), wavs[0], sr)
    duration = len(wavs[0]) / sr

    print(f"\nSaved: {output_path}")
    print(f"Duration: {duration:.1f}s ({duration/60:.1f} minutes)")
    print(f"Sample rate: {sr} Hz")

    return {
        "duration_seconds": duration,
        "sample_rate": sr,
        "samples": len(wavs[0]),
    }


def main():
    parser = argparse.ArgumentParser(
        description="Generate single TTS audio from all scene files",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
    python narrate-full.py ./output/scenes/
    python narrate-full.py ./output/scenes/ --force
    python narrate-full.py ./output/scenes/ --speaker custom_voice
        """,
    )
    parser.add_argument(
        "scenes_dir",
        type=Path,
        help="Directory containing scene .txt files",
    )
    parser.add_argument(
        "--force",
        "-f",
        action="store_true",
        help="Force regeneration even if output exists",
    )
    parser.add_argument(
        "--speaker",
        "-s",
        type=str,
        default=DEFAULT_SPEAKER,
        help=f"Speaker name (default: {DEFAULT_SPEAKER})",
    )
    parser.add_argument(
        "--output",
        "-o",
        type=Path,
        default=None,
        help="Output file path (default: <scenes_dir>/../full-narration.wav)",
    )
    args = parser.parse_args()

    scenes_dir = args.scenes_dir.resolve()

    if not scenes_dir.exists():
        print(f"Error: Directory not found: {scenes_dir}")
        sys.exit(1)

    # Determine output path
    if args.output:
        output_path = args.output.resolve()
    else:
        output_path = scenes_dir.parent / "full-narration.wav"

    # Check if output exists
    if output_path.exists() and not args.force:
        print(f"Output already exists: {output_path}")
        print("Use --force to regenerate.")
        sys.exit(0)

    # Find scene files
    scene_files = find_scene_files(scenes_dir)

    if not scene_files:
        print(f"No .txt files found in: {scenes_dir}")
        sys.exit(1)

    print(f"Found {len(scene_files)} scene files:")

    # Combine all scene texts
    combined_text = combine_scene_texts(scene_files)

    if not combined_text.strip():
        print("Error: No text content found in scene files")
        sys.exit(1)

    # Load model
    tts = load_model()

    # Generate audio
    result = narrate_text(tts, combined_text, output_path, args.speaker)

    if result:
        print("\n" + "=" * 40)
        print("SUCCESS: Full narration generated!")
        print(f"Output: {output_path}")
        print(f"Duration: {result['duration_seconds']:.1f}s")
    else:
        print("\nFailed to generate narration")
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
narrate-scenes.py - Generate TTS audio for scene files.

Converts scene .txt files to .wav audio using the bundled fine-tuned voice model.

Usage:
    # Process all txt files in scenes directory
    python narrate-scenes.py ./output/scenes/

    # Force regeneration of existing outputs
    python narrate-scenes.py ./output/scenes/ --force

    # Use a different speaker
    python narrate-scenes.py ./output/scenes/ --speaker other_voice
"""
import argparse
import json
import os
import sys
from pathlib import Path

import soundfile as sf
import torch
from qwen_tts import Qwen3TTSModel


# Directory setup (relative to script location)
SCRIPT_DIR = Path(__file__).parent.resolve()
SKILL_DIR = SCRIPT_DIR.parent
MODEL_DIR = SKILL_DIR / "tts" / "model"

# Default speaker name (from fine-tuning)
DEFAULT_SPEAKER = "jwynia"


def load_model():
    """Load the fine-tuned TTS model."""
    print("Loading TTS model...")
    print(f"  Model path: {MODEL_DIR}")

    if not MODEL_DIR.exists():
        print(f"Error: Model directory not found at {MODEL_DIR}")
        print("Make sure the model has been moved from inbox/portable-narrator/model/")
        sys.exit(1)

    # Determine device
    if torch.backends.mps.is_available():
        device = "mps"
    elif torch.cuda.is_available():
        device = "cuda"
    else:
        device = "cpu"

    print(f"  Device: {device}")

    tts = Qwen3TTSModel.from_pretrained(
        str(MODEL_DIR),
        device_map=device,
        dtype=torch.float32,
        attn_implementation="sdpa",
    )

    print("Model loaded!\n")
    return tts


def find_scene_files(scenes_dir: Path) -> list[Path]:
    """Find all .txt scene files in the directory."""
    files = list(scenes_dir.glob("*.txt"))
    # Sort by scene number (assumes NN-slug.txt format)
    files.sort(key=lambda f: f.name)
    return files


def get_output_path(input_path: Path) -> Path:
    """Get the output path for an input file."""
    return input_path.with_suffix(".wav")


def read_text_file(filepath: Path) -> str:
    """Read and return the contents of a text file."""
    with open(filepath, "r", encoding="utf-8") as f:
        return f.read().strip()


def narrate_file(tts, input_path: Path, output_path: Path, speaker: str) -> dict | None:
    """Generate speech for a single file. Returns metadata or None on error."""
    print(f"Processing: {input_path.name}")

    # Read text
    text = read_text_file(input_path)
    if not text:
        print(f"  Skipping: file is empty")
        return None

    # Show text preview
    preview = text[:100].replace("\n", " ")
    if len(text) > 100:
        preview += "..."
    print(f"  Text: {preview}")

    # Generate speech
    print(f"  Generating speech...")
    try:
        wavs, sr = tts.generate_custom_voice(
            text=text,
            speaker=speaker,
        )
    except Exception as e:
        print(f"  Error generating speech: {e}")
        return None

    # Save output
    sf.write(str(output_path), wavs[0], sr)
    duration = len(wavs[0]) / sr
    print(f"  Saved: {output_path.name} ({duration:.1f}s)")

    return {
        "duration_seconds": duration,
        "sample_rate": sr,
        "samples": len(wavs[0]),
    }


def update_manifest(scenes_dir: Path, audio_metadata: dict[str, dict]):
    """Update manifest.json with audio information."""
    manifest_path = scenes_dir.parent / "manifest.json"

    if not manifest_path.exists():
        print(f"Warning: No manifest.json found at {manifest_path}")
        return

    with open(manifest_path, "r") as f:
        manifest = json.load(f)

    # Update each scene with audio info
    for scene in manifest.get("scenes", []):
        text_file = scene.get("files", {}).get("text", "")
        if text_file:
            # Convert text filename to audio filename
            txt_name = Path(text_file).name
            wav_name = txt_name.replace(".txt", ".wav")

            if wav_name in audio_metadata:
                meta = audio_metadata[wav_name]
                scene["audio_duration_seconds"] = meta["duration_seconds"]
                scene["files"]["audio"] = f"scenes/{wav_name}"

    # Calculate total duration
    total_duration = sum(
        s.get("audio_duration_seconds", 0) for s in manifest.get("scenes", [])
    )
    manifest["total_duration_seconds"] = total_duration

    # Write updated manifest
    with open(manifest_path, "w") as f:
        json.dump(manifest, f, indent=2)

    print(f"\nUpdated manifest: {manifest_path}")
    print(f"Total audio duration: {total_duration:.1f}s")


def main():
    parser = argparse.ArgumentParser(
        description="Generate TTS audio for scene files",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
    python narrate-scenes.py ./output/scenes/
    python narrate-scenes.py ./output/scenes/ --force
    python narrate-scenes.py ./output/scenes/ --speaker custom_voice
        """,
    )
    parser.add_argument(
        "scenes_dir",
        type=Path,
        help="Directory containing scene .txt files",
    )
    parser.add_argument(
        "--force",
        "-f",
        action="store_true",
        help="Force regeneration even if output exists",
    )
    parser.add_argument(
        "--speaker",
        "-s",
        type=str,
        default=DEFAULT_SPEAKER,
        help=f"Speaker name (default: {DEFAULT_SPEAKER})",
    )
    args = parser.parse_args()

    scenes_dir = args.scenes_dir.resolve()

    if not scenes_dir.exists():
        print(f"Error: Directory not found: {scenes_dir}")
        sys.exit(1)

    # Find scene files
    scene_files = find_scene_files(scenes_dir)

    if not scene_files:
        print(f"No .txt files found in: {scenes_dir}")
        sys.exit(0)

    # Filter out files that already have output (unless --force)
    files_to_process = []
    for input_path in scene_files:
        output_path = get_output_path(input_path)
        if output_path.exists() and not args.force:
            print(f"Skipping (output exists): {input_path.name}")
        else:
            files_to_process.append((input_path, output_path))

    if not files_to_process:
        print("\nNo new files to process. Use --force to regenerate.")
        sys.exit(0)

    print(f"\nFiles to process: {len(files_to_process)}")
    print("-" * 40)

    # Load model
    tts = load_model()

    # Process each file
    audio_metadata = {}
    success_count = 0

    for input_path, output_path in files_to_process:
        try:
            result = narrate_file(tts, input_path, output_path, args.speaker)
            if result:
                audio_metadata[output_path.name] = result
                success_count += 1
        except Exception as e:
            print(f"  Error: {e}")
        print()

    print("-" * 40)
    print(f"Completed: {success_count}/{len(files_to_process)} files")

    # Update manifest with audio info
    if audio_metadata:
        update_manifest(scenes_dir, audio_metadata)


if __name__ == "__main__":
    main()

#!/usr/bin/env -S deno run --allow-read --allow-write

/**
 * split-to-scenes.ts
 *
 * Parse a markdown document and analyze its structure for scene splitting.
 * This script handles the mechanical aspects - the agent determines boundaries.
 *
 * Usage:
 *   # Analyze document structure
 *   deno run --allow-read scripts/split-to-scenes.ts input.md --analyze
 *
 *   # Split using boundaries file (agent-generated)
 *   deno run --allow-read --allow-write scripts/split-to-scenes.ts input.md --boundaries boundaries.json --output ./output/
 *
 *   # Split by headings (simple heuristic fallback)
 *   deno run --allow-read --allow-write scripts/split-to-scenes.ts input.md --by-headings --output ./output/
 *
 *   # Dry run
 *   deno run --allow-read scripts/split-to-scenes.ts input.md --boundaries boundaries.json --dry-run
 */

// ============================================================================
// Types
// ============================================================================

interface DocumentSection {
  type: 'heading' | 'paragraph' | 'list' | 'blockquote' | 'code';
  level?: number; // For headings
  text: string;
  lineStart: number;
  lineEnd: number;
  wordCount: number;
}

interface DocumentAnalysis {
  filename: string;
  totalLines: number;
  totalWords: number;
  sections: DocumentSection[];
  headings: { level: number; text: string; lineNumber: number }[];
  suggestedBreakpoints: number[]; // Line numbers where breaks might occur
}

interface SceneBoundary {
  sceneNumber: number;
  slug: string;
  startLine: number;
  endLine: number;
  content?: string; // Optional: agent can provide pre-processed content
}

interface BoundariesSpec {
  source: string;
  scenes: SceneBoundary[];
}

interface ManifestScene {
  number: number;
  slug: string;
  word_count: number;
  files: {
    text: string;
  };
  source_lines: {
    start: number;
    end: number;
  };
}

interface Manifest {
  source: string;
  created_at: string;
  total_scenes: number;
  scenes: ManifestScene[];
}

// ============================================================================
// Parsing
// ============================================================================

function parseMarkdown(content: string): DocumentSection[] {
  const lines = content.split('\n');
  const sections: DocumentSection[] = [];
  let currentParagraph: string[] = [];
  let paragraphStart = 0;

  const flushParagraph = (endLine: number) => {
    if (currentParagraph.length > 0) {
      const text = currentParagraph.join('\n').trim();
      if (text) {
        sections.push({
          type: 'paragraph',
          text,
          lineStart: paragraphStart,
          lineEnd: endLine - 1,
          wordCount: countWords(text),
        });
      }
      currentParagraph = [];
    }
  };

  for (let i = 0; i < lines.length; i++) {
    const line = lines[i];
    const lineNum = i + 1;

    // Heading
    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
    if (headingMatch) {
      flushParagraph(lineNum);
      sections.push({
        type: 'heading',
        level: headingMatch[1].length,
        text: headingMatch[2].trim(),
        lineStart: lineNum,
        lineEnd: lineNum,
        wordCount: countWords(headingMatch[2]),
      });
      paragraphStart = lineNum + 1;
      continue;
    }

    // Blockquote
    if (line.startsWith('>')) {
      flushParagraph(lineNum);
      const text = line.replace(/^>\s*/, '');
      sections.push({
        type: 'blockquote',
        text,
        lineStart: lineNum,
        lineEnd: lineNum,
        wordCount: countWords(text),
      });
      paragraphStart = lineNum + 1;
      continue;
    }

    // Code block start
    if (line.startsWith('```')) {
      flushParagraph(lineNum);
      const codeStart = lineNum;
      let codeEnd = lineNum;
      const codeLines: string[] = [line];

      // Find end of code block
      for (let j = i + 1; j < lines.length; j++) {
        codeLines.push(lines[j]);
        if (lines[j].startsWith('```')) {
          codeEnd = j + 1;
          i = j;
          break;
        }
      }

      sections.push({
        type: 'code',
        text: codeLines.join('\n'),
        lineStart: codeStart,
        lineEnd: codeEnd,
        wordCount: 0, // Code blocks don't count toward word count
      });
      paragraphStart = codeEnd + 1;
      continue;
    }

    // List item
    if (line.match(/^[\-\*\+]\s/) || line.match(/^\d+\.\s/)) {
      flushParagraph(lineNum);
      const text = line.replace(/^[\-\*\+]\s/, '').replace(/^\d+\.\s/, '');
      sections.push({
        type: 'list',
        text,
        lineStart: lineNum,
        lineEnd: lineNum,
        wordCount: countWords(text),
      });
      paragraphStart = lineNum + 1;
      continue;
    }

    // Empty line
    if (line.trim() === '') {
      flushParagraph(lineNum);
      paragraphStart = lineNum + 1;
      continue;
    }

    // Regular paragraph content
    if (currentParagraph.length === 0) {
      paragraphStart = lineNum;
    }
    currentParagraph.push(line);
  }

  flushParagraph(lines.length + 1);
  return sections;
}

function countWords(text: string): number {
  return text
    .replace(/[#*_`\[\]()]/g, '')
    .split(/\s+/)
    .filter((w) => w.length > 0).length;
}

function analyzeDocument(filename: string, content: string): DocumentAnalysis {
  const sections = parseMarkdown(content);
  const lines = content.split('\n');

  const headings = sections
    .filter((s) => s.type === 'heading')
    .map((s) => ({
      level: s.level!,
      text: s.text,
      lineNumber: s.lineStart,
    }));

  // Suggest breakpoints: after each H2 heading's content
  const suggestedBreakpoints: number[] = [];
  for (let i = 0; i < sections.length; i++) {
    const section = sections[i];
    if (section.type === 'heading' && section.level === 2) {
      // Find the next H2 or end of document
      let breakLine = lines.length;
      for (let j = i + 1; j < sections.length; j++) {
        if (sections[j].type === 'heading' && sections[j].level! <= 2) {
          breakLine = sections[j].lineStart - 1;
          break;
        }
      }
      suggestedBreakpoints.push(breakLine);
    }
  }

  return {
    filename,
    totalLines: lines.length,
    totalWords: sections.reduce((sum, s) => sum + s.wordCount, 0),
    sections,
    headings,
    suggestedBreakpoints,
  };
}

// ============================================================================
// Scene Extraction
// ============================================================================

function extractSceneContent(
  content: string,
  startLine: number,
  endLine: number
): string {
  const lines = content.split('\n');
  return lines.slice(startLine - 1, endLine).join('\n').trim();
}

function generateSlug(text: string): string {
  return text
    .toLowerCase()
    .replace(/[^a-z0-9\s-]/g, '')
    .replace(/\s+/g, '-')
    .slice(0, 30)
    .replace(/-+$/, '');
}

function splitByHeadings(
  content: string,
  analysis: DocumentAnalysis
): SceneBoundary[] {
  const scenes: SceneBoundary[] = [];
  const h2Headings = analysis.headings.filter((h) => h.level === 2);

  if (h2Headings.length === 0) {
    // No H2 headings, treat entire document as one scene
    return [
      {
        sceneNumber: 1,
        slug: generateSlug(analysis.headings[0]?.text || 'document'),
        startLine: 1,
        endLine: analysis.totalLines,
      },
    ];
  }

  // Content before first H2 (if any)
  if (h2Headings[0].lineNumber > 1) {
    const firstSection = analysis.sections[0];
    const slugText =
      firstSection?.type === 'heading' ? firstSection.text : 'opening';
    scenes.push({
      sceneNumber: 1,
      slug: generateSlug(slugText),
      startLine: 1,
      endLine: h2Headings[0].lineNumber - 1,
    });
  }

  // Each H2 section
  for (let i = 0; i < h2Headings.length; i++) {
    const heading = h2Headings[i];
    const nextHeading = h2Headings[i + 1];
    const endLine = nextHeading
      ? nextHeading.lineNumber - 1
      : analysis.totalLines;

    scenes.push({
      sceneNumber: scenes.length + 1,
      slug: generateSlug(heading.text),
      startLine: heading.lineNumber,
      endLine,
    });
  }

  return scenes;
}

// ============================================================================
// Output
// ============================================================================

async function writeScenes(
  content: string,
  boundaries: SceneBoundary[],
  outputDir: string,
  dryRun: boolean
): Promise<Manifest> {
  const scenesDir = `${outputDir}/scenes`;

  if (!dryRun) {
    await Deno.mkdir(scenesDir, { recursive: true });
  }

  const manifestScenes: ManifestScene[] = [];

  for (const boundary of boundaries) {
    const paddedNum = String(boundary.sceneNumber).padStart(2, '0');
    const filename = `${paddedNum}-${boundary.slug}.txt`;
    const filepath = `${scenesDir}/${filename}`;

    const sceneContent =
      boundary.content ||
      extractSceneContent(content, boundary.startLine, boundary.endLine);

    const wordCount = countWords(sceneContent);

    if (dryRun) {
      console.log(`\n[Scene ${boundary.sceneNumber}] ${filename}`);
      console.log(`  Lines: ${boundary.startLine}-${boundary.endLine}`);
      console.log(`  Words: ${wordCount}`);
      console.log(`  Preview: ${sceneContent.slice(0, 100)}...`);
    } else {
      await Deno.writeTextFile(filepath, sceneContent);
      console.log(`Wrote: ${filepath} (${wordCount} words)`);
    }

    manifestScenes.push({
      number: boundary.sceneNumber,
      slug: boundary.slug,
      word_count: wordCount,
      files: {
        text: `scenes/${filename}`,
      },
      source_lines: {
        start: boundary.startLine,
        end: boundary.endLine,
      },
    });
  }

  const manifest: Manifest = {
    source: '',
    created_at: new Date().toISOString(),
    total_scenes: boundaries.length,
    scenes: manifestScenes,
  };

  if (!dryRun) {
    const manifestPath = `${outputDir}/manifest.json`;
    await Deno.writeTextFile(manifestPath, JSON.stringify(manifest, null, 2));
    console.log(`\nWrote: ${manifestPath}`);
  }

  return manifest;
}

// ============================================================================
// Main
// ============================================================================

function printHelp() {
  console.log(`
split-to-scenes.ts - Parse documents for scene splitting

USAGE:
  deno run --allow-read scripts/split-to-scenes.ts <input.md> [options]

OPTIONS:
  --analyze              Analyze document structure and output JSON
  --by-headings          Split document by H2 headings (simple heuristic)
  --boundaries <file>    Use agent-generated boundaries JSON file
  --output <dir>         Output directory for scene files
  --dry-run              Preview splits without writing files
  --help, -h             Show this help

MODES:
  1. Analyze mode: Inspect document structure
     deno run --allow-read scripts/split-to-scenes.ts doc.md --analyze

  2. Headings mode: Split by H2 headings
     deno run --allow-read --allow-write scripts/split-to-scenes.ts doc.md --by-headings --output ./out

  3. Boundaries mode: Use agent-specified boundaries
     deno run --allow-read --allow-write scripts/split-to-scenes.ts doc.md --boundaries b.json --output ./out

BOUNDARIES FILE FORMAT:
  {
    "source": "document.md",
    "scenes": [
      { "sceneNumber": 1, "slug": "opening", "startLine": 1, "endLine": 15 },
      { "sceneNumber": 2, "slug": "main-point", "startLine": 16, "endLine": 45 }
    ]
  }

  Or with pre-processed content:
  {
    "scenes": [
      { "sceneNumber": 1, "slug": "opening", "startLine": 1, "endLine": 15,
        "content": "Adapted spoken text here..." }
    ]
  }
`);
}

async function main() {
  const args = Deno.args;

  if (args.includes('--help') || args.includes('-h') || args.length === 0) {
    printHelp();
    Deno.exit(0);
  }

  // Parse arguments
  const inputFile = args.find((a) => !a.startsWith('--'));
  const analyze = args.includes('--analyze');
  const byHeadings = args.includes('--by-headings');
  const dryRun = args.includes('--dry-run');

  const boundariesIdx = args.indexOf('--boundaries');
  const boundariesFile = boundariesIdx >= 0 ? args[boundariesIdx + 1] : null;

  const outputIdx = args.indexOf('--output');
  const outputDir = outputIdx >= 0 ? args[outputIdx + 1] : null;

  if (!inputFile) {
    console.error('Error: No input file specified');
    Deno.exit(1);
  }

  // Read input document
  let content: string;
  try {
    content = await Deno.readTextFile(inputFile);
  } catch {
    console.error(`Error: Could not read file: ${inputFile}`);
    Deno.exit(1);
  }

  const analysis = analyzeDocument(inputFile, content);

  // Mode: Analyze
  if (analyze) {
    console.log(JSON.stringify(analysis, null, 2));
    Deno.exit(0);
  }

  // Mode: Split by headings or boundaries
  if (!outputDir && !dryRun) {
    console.error('Error: --output directory required (or use --dry-run)');
    Deno.exit(1);
  }

  let boundaries: SceneBoundary[];

  if (boundariesFile) {
    // Use agent-specified boundaries
    try {
      const boundariesContent = await Deno.readTextFile(boundariesFile);
      const spec: BoundariesSpec = JSON.parse(boundariesContent);
      boundaries = spec.scenes;
    } catch (e) {
      console.error(`Error: Could not read boundaries file: ${e}`);
      Deno.exit(1);
    }
  } else if (byHeadings) {
    // Simple heuristic: split by H2 headings
    boundaries = splitByHeadings(content, analysis);
  } else {
    console.error('Error: Specify --by-headings or --boundaries <file>');
    Deno.exit(1);
  }

  // Write scenes
  const manifest = await writeScenes(
    content,
    boundaries,
    outputDir || './output',
    dryRun
  );

  if (!dryRun) {
    manifest.source = inputFile;
    const manifestPath = `${outputDir}/manifest.json`;
    await Deno.writeTextFile(manifestPath, JSON.stringify(manifest, null, 2));
  }

  console.log(`\nTotal scenes: ${boundaries.length}`);
}

main();

#!/usr/bin/env python3
"""
transcribe-full.py - Generate word-level timestamps from audio using Whisper.

Transcribes an audio file and generates:
1. VTT file with word-level timestamps (for video players)
2. JSON file with captions (for Remotion CaptionRenderer)

Usage:
    python transcribe-full.py ./narration/full-narration.wav
    python transcribe-full.py ./narration/full-narration.wav --model medium
"""
import argparse
import json
import sys
from pathlib import Path

try:
    import whisper
except ImportError:
    print("Error: openai-whisper not installed")
    print("Install with: pip install openai-whisper")
    sys.exit(1)


def format_vtt_timestamp(seconds: float) -> str:
    """Convert seconds to VTT timestamp format (MM:SS.mmm)."""
    minutes = int(seconds // 60)
    secs = seconds % 60
    return f"{minutes:02d}:{secs:06.3f}"


def transcribe_with_timestamps(audio_path: Path, model_name: str = "medium") -> dict:
    """Transcribe audio with word-level timestamps."""
    print(f"Loading Whisper model '{model_name}'...")
    model = whisper.load_model(model_name)

    print(f"Transcribing: {audio_path}")
    print("(This may take a few minutes...)")

    result = model.transcribe(
        str(audio_path),
        word_timestamps=True,
        language="en",
        verbose=False,
    )

    return result


def to_vtt(result: dict, output_path: Path):
    """Convert whisper result to VTT format with word-level timestamps."""
    with open(output_path, "w", encoding="utf-8") as f:
        f.write("WEBVTT\n\n")

        cue_index = 1
        for segment in result.get("segments", []):
            words = segment.get("words", [])
            if not words:
                continue

            for word_info in words:
                word = word_info.get("word", "").strip()
                if not word:
                    continue

                start = format_vtt_timestamp(word_info["start"])
                end = format_vtt_timestamp(word_info["end"])

                f.write(f"{cue_index}\n")
                f.write(f"{start} --> {end}\n")
                f.write(f"{word}\n\n")
                cue_index += 1

    print(f"Saved VTT: {output_path} ({cue_index - 1} cues)")


def to_json(result: dict, output_path: Path):
    """Convert whisper result to JSON for Remotion captions."""
    captions = []

    for segment in result.get("segments", []):
        words = segment.get("words", [])
        if not words:
            continue

        for word_info in words:
            word = word_info.get("word", "").strip()
            if not word:
                continue

            captions.append({
                "text": word,
                "startMs": int(word_info["start"] * 1000),
                "endMs": int(word_info["end"] * 1000),
                "confidence": word_info.get("probability", 1.0),
            })

    output_data = {
        "segments": result.get("segments", []),
        "captions": captions,
        "text": result.get("text", ""),
        "language": result.get("language", "en"),
    }

    with open(output_path, "w", encoding="utf-8") as f:
        json.dump(output_data, f, indent=2, ensure_ascii=False)

    print(f"Saved JSON: {output_path} ({len(captions)} words)")


def main():
    parser = argparse.ArgumentParser(
        description="Transcribe audio with word-level timestamps using Whisper",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
    python transcribe-full.py ./narration/full-narration.wav
    python transcribe-full.py ./narration/full-narration.wav --model large-v3
    python transcribe-full.py audio.wav --output-dir ./output/
        """,
    )
    parser.add_argument(
        "audio_path",
        type=Path,
        help="Path to audio file (WAV, MP3, etc.)",
    )
    parser.add_argument(
        "--model",
        "-m",
        type=str,
        default="medium",
        choices=["tiny", "base", "small", "medium", "large", "large-v2", "large-v3"],
        help="Whisper model size (default: medium)",
    )
    parser.add_argument(
        "--output-dir",
        "-o",
        type=Path,
        default=None,
        help="Output directory (default: same as audio file)",
    )
    args = parser.parse_args()

    audio_path = args.audio_path.resolve()

    if not audio_path.exists():
        print(f"Error: Audio file not found: {audio_path}")
        sys.exit(1)

    # Determine output paths
    if args.output_dir:
        output_dir = args.output_dir.resolve()
        output_dir.mkdir(parents=True, exist_ok=True)
    else:
        output_dir = audio_path.parent

    base_name = audio_path.stem
    vtt_path = output_dir / f"{base_name}.vtt"
    json_path = output_dir / f"{base_name}.json"

    # Transcribe
    result = transcribe_with_timestamps(audio_path, args.model)

    # Check if we got word-level timestamps
    has_words = any(
        segment.get("words")
        for segment in result.get("segments", [])
    )

    if not has_words:
        print("Warning: No word-level timestamps found in transcription")
        print("This may happen with some audio files or model versions")

    # Generate outputs
    print("\nGenerating output files...")
    to_vtt(result, vtt_path)
    to_json(result, json_path)

    # Summary
    print("\n" + "=" * 40)
    print("SUCCESS: Transcription complete!")
    print(f"VTT:  {vtt_path}")
    print(f"JSON: {json_path}")

    # Word count
    word_count = sum(
        len(segment.get("words", []))
        for segment in result.get("segments", [])
    )
    print(f"Words: {word_count}")


if __name__ == "__main__":
    main()