opencode-skills-collection 3.1.12 → 3.1.14

package/bundled-skills/gemini-omni-flash-api/scripts/video/inspect_video.py

@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import os
+import subprocess
+import sys
+
+def format_size(size_bytes):
+    """Formats file size in bytes to a human-readable string."""
+    try:
+        size_bytes = int(size_bytes)
+    except (ValueError, TypeError):
+        return "Unknown size"
+
+    for unit in ['B', 'KB', 'MB', 'GB']:
+        if size_bytes < 1024.0:
+            return f"{size_bytes:.2f} {unit}"
+        size_bytes /= 1024.0
+    return f"{size_bytes:.2f} TB"
+
+def parse_fps(fps_str):
+    """Parses fractional frame rates like '30/1' or '24000/1001' into floats."""
+    if not fps_str:
+        return "Unknown"
+    if "/" in fps_str:
+        try:
+            num, den = map(float, fps_str.split("/"))
+            if den != 0:
+                val = num / den
+                if val.is_integer():
+                    return f"{int(val)} fps"
+                return f"{val:.2f} fps"
+        except (ValueError, ZeroDivisionError):
+            pass
+    try:
+        val = float(fps_str)
+        if val.is_integer():
+            return f"{int(val)} fps"
+        return f"{val:.2f} fps"
+    except ValueError:
+        return fps_str
+
+def inspect_video(file_path, raw=False):
+    """Runs ffprobe on the video file and returns parsed metadata dictionary."""
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"File not found: {file_path}")
+
+    # Check if ffprobe is available
+    try:
+        subprocess.run(["ffprobe", "-version"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+    except (subprocess.SubprocessError, FileNotFoundError):
+        raise RuntimeError("ffprobe is not installed or not found in system PATH.")
+
+    cmd = [
+        "ffprobe",
+        "-v", "error",
+        "-show_format",
+        "-show_streams",
+        "-of", "json",
+        file_path
+    ]
+
+    result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, check=True)
+    data = json.loads(result.stdout)
+
+    if raw:
+        return data
+
+    # Extract format level details
+    fmt = data.get("format", {})
+    duration = fmt.get("duration")
+    size_bytes = fmt.get("size")
+    bitrate = fmt.get("bit_rate")
+
+    # Format files size
+    size_str = format_size(size_bytes) if size_bytes else "Unknown"
+
+    # Parse duration
+    try:
+        duration_val = float(duration) if duration else 0.0
+        duration_str = f"{duration_val:.2f}s"
+    except ValueError:
+        duration_str = "Unknown"
+        duration_val = None
+
+    # Parse bitrate
+    try:
+        bitrate_kbps = f"{int(float(bitrate) / 1000)} kbps" if bitrate else "Unknown"
+    except ValueError:
+        bitrate_kbps = "Unknown"
+
+    video_streams = [s for s in data.get("streams", []) if s.get("codec_type") == "video"]
+    audio_streams = [s for s in data.get("streams", []) if s.get("codec_type") == "audio"]
+
+    has_video = len(video_streams) > 0
+    has_audio = len(audio_streams) > 0
+
+    video_info = {}
+    if has_video:
+        v = video_streams[0]
+        width = v.get("width")
+        height = v.get("height")
+        codec = v.get("codec_name", "Unknown").upper()
+        r_fps = parse_fps(v.get("r_frame_rate"))
+        avg_fps = parse_fps(v.get("avg_frame_rate"))
+
+        # Prefer r_frame_rate but fallback to avg
+        fps = r_fps if r_fps != "0 fps" and r_fps != "Unknown" else avg_fps
+
+        video_info = {
+            "resolution": f"{width}x{height}" if width and height else "Unknown",
+            "width": width,
+            "height": height,
+            "fps": fps,
+            "codec": codec,
+            "duration": v.get("duration")
+        }
+
+    audio_info = {}
+    if has_audio:
+        a = audio_streams[0]
+        codec = a.get("codec_name", "Unknown").upper()
+        channels = a.get("channels", "Unknown")
+        sample_rate = a.get("sample_rate")
+        sample_rate_khz = f"{float(sample_rate)/1000:.1f} kHz" if sample_rate else "Unknown"
+
+        audio_info = {
+            "codec": codec,
+            "channels": channels,
+            "sample_rate": sample_rate_khz
+        }
+
+    return {
+        "file_name": os.path.basename(file_path),
+        "file_size": size_str,
+        "size_bytes": size_bytes,
+        "duration": duration_str,
+        "duration_seconds": duration_val,
+        "bitrate": bitrate_kbps,
+        "has_video": has_video,
+        "video": video_info,
+        "has_audio": has_audio,
+        "audio": audio_info
+    }
+
+def print_terminal_report(info):
+    """Prints an aligned terminal report."""
+    print(f"\nVideo Inspection Report: {info['file_name']}")
+    print("=" * 50)
+    print(f"File Size   : {info['file_size']}")
+    print(f"Duration    : {info['duration']}")
+    print(f"Bitrate     : {info['bitrate']}")
+
+    print("\nVideo Stream Details:")
+    if info["has_video"]:
+        v = info["video"]
+        print(f"  * Resolution : {v['resolution']}")
+        print(f"  * Frame Rate : {v['fps']}")
+        print(f"  * Codec      : {v['codec']}")
+    else:
+        print("  * No Video Stream Found.")
+
+    print("\nAudio Stream Details:")
+    if info["has_audio"]:
+        a = info["audio"]
+        print("  * Status     : Audio Present")
+        print(f"  * Codec      : {a['codec']}")
+        print(f"  * Channels   : {a['channels']}")
+        print(f"  * Sample Rate: {a['sample_rate']}")
+    else:
+        print("  * Status     : No Audio Stream Present")
+    print()
+
+def main():
+    parser = argparse.ArgumentParser(description="Inspect video details (duration, frame rate, resolution, audio presence) using ffprobe.")
+    parser.add_argument("file", help="Path to the video file to inspect")
+    parser.add_argument("--json", action="store_true", help="Output parsed summary in JSON format")
+    parser.add_argument("--raw", action="store_true", help="Output raw unmodified ffprobe JSON data")
+
+    args = parser.parse_args()
+
+    try:
+        if args.raw:
+            info = inspect_video(args.file, raw=True)
+            print(json.dumps(info, indent=2))
+        else:
+            info = inspect_video(args.file, raw=False)
+            if args.json:
+                print(json.dumps(info, indent=2))
+            else:
+                print_terminal_report(info)
+    except Exception as e:
+        print(f"Error inspecting video: {e}", file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

package/bundled-skills/gemini-omni-flash-api/scripts/video/prep_video.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import subprocess
+import sys
+from inspect_video import inspect_video, format_size
+
+def parse_timecode(time_str, total_duration=None):
+    """Parses a time string (seconds, MM:SS, HH:MM:SS, or 'last') into float seconds."""
+    if not time_str:
+        return 0.0
+    time_str = time_str.strip().lower()
+
+    if time_str == "last":
+        if total_duration is None:
+            raise ValueError("Total duration is required to calculate 'last' starting point.")
+        target_dur = 10.0
+        if total_duration <= target_dur:
+            return 0.0
+        return total_duration - target_dur
+
+    if ":" in time_str:
+        parts = time_str.split(":")
+        if len(parts) == 2:  # MM:SS
+            m, s = map(float, parts)
+            return m * 60.0 + s
+        elif len(parts) == 3:  # HH:MM:SS
+            h, m, s = map(float, parts)
+            return h * 3600.0 + m * 60.0 + s
+        else:
+            raise ValueError(f"Invalid timecode format: '{time_str}'. Use HH:MM:SS or MM:SS.")
+
+    try:
+        return float(time_str)
+    except ValueError:
+        raise ValueError(f"Invalid timecode: '{time_str}'. Must be float seconds, HH:MM:SS, or 'last'.")
+
+def prep_video(input_path, output_path, start_time_str=None, duration=10, fps=None, resolution=None, strip_audio=False):
+    """Preps a video file by trimming, optionally re-encoding to target fps and resolution."""
+    if not os.path.exists(input_path):
+        raise FileNotFoundError(f"Input file not found: {input_path}")
+
+    # Check if ffmpeg is available
+    try:
+        subprocess.run(["ffmpeg", "-version"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+    except (subprocess.SubprocessError, FileNotFoundError):
+        raise RuntimeError("ffmpeg is not installed or not found in system PATH.")
+
+    # Inspect input video first
+    print(f"Analyzing source video: {os.path.basename(input_path)}...")
+    source_info = inspect_video(input_path)
+    total_duration = source_info.get("duration_seconds", 0.0)
+
+    # Resolve start time
+    if start_time_str is None:
+        if total_duration and total_duration > 10.0 and sys.stdin.isatty():
+            print(f"\nThe input video is longer than 10s ({total_duration:.2f}s).")
+            print("Please choose a 10s segment to trim:")
+            print("  1) First 10 seconds [default]")
+            print("  2) Last 10 seconds")
+            print("  3) Custom starting timecode (e.g., MM:SS, HH:MM:SS, or seconds)")
+            try:
+                choice = input("Your choice [1/2/3, default 1]: ").strip()
+                if choice == "2":
+                    start_time_str = "last"
+                elif choice == "3":
+                    custom_start = input("Enter starting timecode (e.g., 00:03 or 15): ").strip()
+                    start_time_str = custom_start if custom_start else "0"
+                else:
+                    start_time_str = "0"
+            except (KeyboardInterrupt, EOFError):
+                print("\nNo input received. Defaulting to first 10 seconds.")
+                start_time_str = "0"
+        else:
+            start_time_str = "0"
+
+    try:
+        start_seconds = parse_timecode(start_time_str, total_duration)
+    except Exception as e:
+        raise ValueError(f"Timecode parsing failed: {e}")
+
+
+    if start_seconds < 0 or (total_duration and start_seconds >= total_duration):
+        raise ValueError(f"Start time {start_seconds}s is out of bounds for video of length {total_duration}s.")
+
+    # Construct output path if not specified
+    if not output_path:
+        os.makedirs("media", exist_ok=True)
+        base_name = os.path.basename(input_path)
+        name, ext = os.path.splitext(base_name)
+        output_path = os.path.join("media", f"prepped_{name}.mp4")
+
+    # Check if the source video file is large (>25MB)
+    size_bytes_str = source_info.get("size_bytes")
+    is_large = False
+    try:
+        if size_bytes_str and int(size_bytes_str) > 25 * 1024 * 1024:
+            is_large = True
+    except (ValueError, TypeError):
+        pass
+
+    # Target resolution parsing
+    scale_filter = None
+    orig_width = None
+    orig_height = None
+    if "video" in source_info:
+        try:
+            orig_width = int(source_info["video"].get("width"))
+            orig_height = int(source_info["video"].get("height"))
+        except (ValueError, TypeError):
+            pass
+
+    if resolution:
+        try:
+            target_w, target_h = map(int, resolution.lower().split("x"))
+            if orig_width and orig_height:
+                # Scale to fit target_w and target_h while preserving aspect ratio
+                scale_factor = min(target_w / orig_width, target_h / orig_height)
+                width = int(orig_width * scale_factor)
+                height = int(orig_height * scale_factor)
+            else:
+                width, height = target_w, target_h
+            # Ensure divisible by 2 for standard decoders/encoders
+            width = (width // 2) * 2
+            height = (height // 2) * 2
+            scale_filter = f"scale={width}:{height}"
+            resolution = f"{width}x{height}"
+        except ValueError:
+            raise ValueError(f"Invalid resolution: '{resolution}'. Format must be WIDTHxHEIGHT (e.g. 1280x720).")
+    elif is_large:
+        if orig_width and orig_height:
+            # Scale down large videos proportionally (max 1280x720 for landscape, 720x1280 for portrait)
+            if orig_width >= orig_height:
+                max_w, max_h = 1280, 720
+            else:
+                max_w, max_h = 720, 1280
+            scale_factor = min(max_w / orig_width, max_h / orig_height)
+            if scale_factor < 1.0:
+                width = int(orig_width * scale_factor)
+                height = int(orig_height * scale_factor)
+            else:
+                width, height = orig_width, orig_height
+        else:
+            width, height = 1280, 720
+
+        # Ensure divisible by 2
+        width = (width // 2) * 2
+        height = (height // 2) * 2
+        resolution = f"{width}x{height}"
+        print(f"\nRecommendation: Source video is very large ({source_info.get('file_size')}).")
+        print("   Automatically scaling to optimize upload times for Gemini Omni Flash.")
+        scale_filter = f"scale={width}:{height}"
+
+    fps_spec = f"{fps} fps" if fps else "Original frame rate"
+    print(f"\nPreparing Video Processing:")
+    print(f"  * Source Duration: {total_duration:.2f}s")
+    print(f"  * Trim Range     : Start at {start_seconds:.2f}s | Length {duration:.2f}s")
+    if resolution:
+        print(f"  * Encoding Specs : {width}x{height} @ {fps_spec}")
+    else:
+        print(f"  * Encoding Specs : Original Resolution @ {fps_spec}")
+    print(f"  * Target Path    : {output_path}")
+    print("=" * 50)
+
+    # ffmpeg command construction
+    cmd = [
+        "ffmpeg",
+        "-y",               # Overwrite output
+        "-ss", str(start_seconds), # Seek start
+        "-i", input_path,   # Input file
+        "-t", str(duration), # Duration to copy
+    ]
+    if scale_filter:
+        cmd.extend(["-vf", scale_filter])
+
+    cmd.extend([
+        "-c:v", "libx264",  # Standard H264 video codec
+        "-pix_fmt", "yuv420p", # Standard pixel format for web/Gemini compatibility
+    ])
+
+    if fps:
+        cmd.extend(["-r", str(fps)]) # Output frame rate if requested
+
+    if strip_audio or not source_info.get("has_audio", False):
+        if not source_info.get("has_audio", False) and not strip_audio:
+            print("No audio stream detected in source video. Disabling audio output.")
+        else:
+            print("Stripping audio stream from video as requested.")
+        cmd.append("-an")   # Disable audio streams completely
+    else:
+        cmd.extend([
+            "-c:a", "aac",      # Convert audio to standard AAC
+            "-b:a", "128k",     # Standard audio bitrate
+            "-ac", "2",         # Convert to stereo
+        ])
+
+    cmd.append(output_path)
+
+    print("Running ffmpeg encoding...")
+    process = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+
+    if process.returncode != 0:
+        print("Error: ffmpeg failed. Stderr output follows:", file=sys.stderr)
+        print(process.stderr, file=sys.stderr)
+        raise RuntimeError("ffmpeg execution failed.")
+
+    print("Video preparation completed successfully!")
+    print("=" * 50)
+
+    # Call inspection tool on output to print clean specs
+    output_info = inspect_video(output_path)
+    return output_info
+
+def main():
+    parser = argparse.ArgumentParser(description="Prep videos for editing (trimming, re-encoding to target fps and resolution).")
+    parser.add_argument("file", help="Path to the source video file to prep")
+    parser.add_argument("--start", "-s", default=None, help="Start timecode (seconds, MM:SS, HH:MM:SS, or 'last' for last 10s). Default: 0 (or prompted if > 10s)")
+    parser.add_argument("--duration", "-d", type=int, default=10, help="Duration of trimmed segment in seconds. Default: 10")
+    parser.add_argument("--fps", "-r", type=int, default=None, help="Target frame rate. Default: None (keep original frame rate)")
+    parser.add_argument("--resolution", "-g", default=None, help="Target resolution (e.g., 1280x720). Default: None (keep original resolution)")
+    parser.add_argument("--output", "-o", help="Custom output path. Defaults to media/prepped_<original_name>.mp4")
+    parser.add_argument("--strip-audio", "-a", action="store_true", help="Completely strip/disable audio stream so the model can generate new audio")
+
+    args = parser.parse_args()
+
+    try:
+        info = prep_video(
+            input_path=args.file,
+            output_path=args.output,
+            start_time_str=args.start,
+            duration=args.duration,
+            fps=args.fps,
+            resolution=args.resolution,
+            strip_audio=args.strip_audio
+        )
+
+        # Display final output report
+        print(f"\nPrepped Video Specifications: {info['file_name']}")
+        print("=" * 50)
+        print(f"File Size   : {info['file_size']}")
+        print(f"Duration    : {info['duration']}")
+        print(f"Bitrate     : {info['bitrate']}")
+        print(f"Resolution  : {info['video']['resolution']}")
+        print(f"Frame Rate  : {info['video']['fps']}")
+        print(f"Video Codec : {info['video']['codec']}")
+        if info["has_audio"]:
+            print(f"Audio Spec  : {info['audio']['codec']} | {info['audio']['channels']} ch | {info['audio']['sample_rate']}")
+        print()
+
+    except Exception as e:
+        print(f"Error prepping video: {e}", file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

package/bundled-skills/gh-image/SKILL.md

@@ -2,7 +2,7 @@
 name: gh-image
 description: "Upload local images to GitHub and get canonical user-attachments embed URLs; use when asked to attach a screenshot to a PR, issue, or comment, or to embed before/after images in a README."
 category: developer-tools
-risk: safe
+risk: critical
 source: community
 source_type: community
 source_repo: drogers0/gh-image
@@ -21,6 +21,14 @@ tools:
   - codex-cli
   - cursor
   - gemini-cli
+plugin:
+  targets:
+    codex: blocked
+    claude: blocked
+  setup:
+    type: manual
+    summary: "Installs and runs a third-party gh extension that needs a GitHub user_session cookie or GH_SESSION_TOKEN."
+    docs: SKILL.md
 ---
 
 # Upload images to GitHub (gh-image)
@@ -53,7 +61,7 @@ Use this skill when asked to:
 ```bash
 gh auth status                                   # gh installed & authenticated
 gh extension list | grep -q 'drogers0/gh-image' \
-  || gh extension install drogers0/gh-image      # idempotent install
+  || gh extension install drogers0/gh-image      # review/pin the extension source first
 ```
 
 `gh-image` does **not** use the `gh` token for the upload (that endpoint rejects