agent-recipes 0.0.5__py3-none-any.whl

agent_recipes/templates/ai-video-editor/src/ai_video_editor/utils.py

@@ -0,0 +1,222 @@
+"""
+Utility functions for AI Video Editor.
+
+Provides:
+- FFmpeg detection and command building
+- File hashing for reproducibility
+- Working directory management
+- Time formatting utilities
+"""
+
+import hashlib
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+import json
+
+
+def check_ffmpeg() -> Tuple[bool, str]:
+    """Check if ffmpeg is available."""
+    try:
+        result = subprocess.run(
+            ["ffmpeg", "-version"],
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        if result.returncode == 0:
+            version_line = result.stdout.split("\n")[0]
+            return True, version_line
+        return False, "ffmpeg returned non-zero exit code"
+    except FileNotFoundError:
+        return False, "ffmpeg not found. Install with: brew install ffmpeg (macOS) or apt install ffmpeg (Linux)"
+    except subprocess.TimeoutExpired:
+        return False, "ffmpeg check timed out"
+    except Exception as e:
+        return False, f"Error checking ffmpeg: {e}"
+
+
+def check_ffprobe() -> Tuple[bool, str]:
+    """Check if ffprobe is available."""
+    try:
+        result = subprocess.run(
+            ["ffprobe", "-version"],
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        if result.returncode == 0:
+            version_line = result.stdout.split("\n")[0]
+            return True, version_line
+        return False, "ffprobe returned non-zero exit code"
+    except FileNotFoundError:
+        return False, "ffprobe not found. Install ffmpeg which includes ffprobe."
+    except subprocess.TimeoutExpired:
+        return False, "ffprobe check timed out"
+    except Exception as e:
+        return False, f"Error checking ffprobe: {e}"
+
+
+def ensure_ffmpeg():
+    """Raise error if ffmpeg is not available."""
+    available, msg = check_ffmpeg()
+    if not available:
+        raise RuntimeError(f"FFmpeg is required but not available: {msg}")
+
+
+def file_hash(path: str, algorithm: str = "sha256") -> str:
+    """Compute hash of a file."""
+    h = hashlib.new(algorithm)
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(8192), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def create_workdir(input_path: str, base_dir: Optional[str] = None) -> Path:
+    """Create a working directory for video processing."""
+    if base_dir is None:
+        base_dir = os.path.join(os.getcwd(), ".praison", "video")
+    
+    input_hash = file_hash(input_path)[:12]
+    input_name = Path(input_path).stem
+    workdir = Path(base_dir) / f"{input_name}_{input_hash}"
+    
+    workdir.mkdir(parents=True, exist_ok=True)
+    (workdir / "audio").mkdir(exist_ok=True)
+    (workdir / "segments").mkdir(exist_ok=True)
+    (workdir / "output").mkdir(exist_ok=True)
+    
+    return workdir
+
+
+def format_duration(seconds: float) -> str:
+    """Format duration in human-readable format."""
+    hours = int(seconds // 3600)
+    minutes = int((seconds % 3600) // 60)
+    secs = int(seconds % 60)
+    
+    parts = []
+    if hours > 0:
+        parts.append(f"{hours}h")
+    if minutes > 0 or hours > 0:
+        parts.append(f"{minutes}m")
+    parts.append(f"{secs}s")
+    
+    return " ".join(parts)
+
+
+def parse_duration(duration_str: str) -> float:
+    """Parse duration string to seconds."""
+    import re
+    
+    total = 0.0
+    
+    h_match = re.search(r"(\d+)h", duration_str)
+    if h_match:
+        total += int(h_match.group(1)) * 3600
+    
+    m_match = re.search(r"(\d+)m", duration_str)
+    if m_match:
+        total += int(m_match.group(1)) * 60
+    
+    s_match = re.search(r"(\d+)s", duration_str)
+    if s_match:
+        total += int(s_match.group(1))
+    
+    if total == 0:
+        try:
+            total = float(duration_str)
+        except ValueError:
+            pass
+    
+    return total
+
+
+def extract_audio(video_path: str, output_path: str, sample_rate: int = 16000, mono: bool = True) -> str:
+    """Extract audio from video file."""
+    ensure_ffmpeg()
+    
+    cmd = [
+        "ffmpeg", "-y",
+        "-i", video_path,
+        "-vn",
+        "-acodec", "pcm_s16le",
+        "-ar", str(sample_rate),
+    ]
+    
+    if mono:
+        cmd.extend(["-ac", "1"])
+    
+    cmd.append(output_path)
+    
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        raise RuntimeError(f"Failed to extract audio: {result.stderr}")
+    
+    return output_path
+
+
+def generate_edl(
+    segments_to_keep: List[Tuple[float, float]],
+    segments_to_remove: List[Tuple[float, float, str]],
+    output_path: str,
+    fps: float = 30.0
+) -> str:
+    """Generate Edit Decision List (EDL) file."""
+    lines = [
+        "TITLE: AI Video Editor EDL",
+        "FCM: NON-DROP FRAME",
+        ""
+    ]
+    
+    for i, (start, end) in enumerate(segments_to_keep, 1):
+        start_tc = _seconds_to_timecode(start, fps)
+        end_tc = _seconds_to_timecode(end, fps)
+        lines.append(f"{i:03d}  AX       V     C        {start_tc} {end_tc} {start_tc} {end_tc}")
+    
+    lines.append("")
+    lines.append("* REMOVED SEGMENTS:")
+    
+    for start, end, reason in segments_to_remove:
+        start_tc = _seconds_to_timecode(start, fps)
+        end_tc = _seconds_to_timecode(end, fps)
+        lines.append(f"* {start_tc} - {end_tc}: {reason}")
+    
+    content = "\n".join(lines)
+    Path(output_path).write_text(content)
+    return output_path
+
+
+def _seconds_to_timecode(seconds: float, fps: float = 30.0) -> str:
+    """Convert seconds to SMPTE timecode."""
+    frames = int((seconds % 1) * fps)
+    total_secs = int(seconds)
+    hours = total_secs // 3600
+    minutes = (total_secs % 3600) // 60
+    secs = total_secs % 60
+    return f"{hours:02d}:{minutes:02d}:{secs:02d}:{frames:02d}"
+
+
+def save_config_snapshot(config: Dict[str, Any], workdir: Path) -> str:
+    """Save configuration snapshot for reproducibility."""
+    config_path = workdir / "config_snapshot.json"
+    with open(config_path, "w") as f:
+        json.dump(config, f, indent=2, default=str)
+    return str(config_path)
+
+
+def cleanup_workdir(workdir: Path, keep_output: bool = True):
+    """Clean up working directory."""
+    if not workdir.exists():
+        return
+    
+    for item in workdir.iterdir():
+        if keep_output and item.name == "output":
+            continue
+        if item.is_dir():
+            shutil.rmtree(item)
+        else:
+            item.unlink()

agent_recipes/templates/ai-video-editor/tests/test_heuristics.py

@@ -0,0 +1,130 @@
+"""
+Unit tests for heuristic-based content analysis.
+"""
+
+import sys
+from pathlib import Path
+
+# Add src to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+import pytest
+
+
+class TestFillerDetection:
+    """Test filler word detection."""
+    
+    def test_detect_fillers(self):
+        from ai_video_editor.models import TranscriptResult, Word
+        from ai_video_editor.heuristics import detect_fillers
+        
+        transcript = TranscriptResult(
+            text="So um I think uh this is like really important",
+            words=[
+                Word(text="So", start=0.0, end=0.2),
+                Word(text="um", start=0.3, end=0.5),
+                Word(text="I", start=0.6, end=0.7),
+                Word(text="think", start=0.7, end=1.0),
+                Word(text="uh", start=1.1, end=1.3),
+                Word(text="this", start=1.4, end=1.6),
+                Word(text="is", start=1.6, end=1.8),
+                Word(text="like", start=1.9, end=2.1),
+                Word(text="really", start=2.2, end=2.5),
+                Word(text="important", start=2.5, end=3.0),
+            ],
+            duration=3.0
+        )
+        
+        filler_words = ["um", "uh", "like"]
+        fillers = detect_fillers(transcript, filler_words)
+        
+        assert len(fillers) == 3
+        assert fillers[0].text == "um"
+        assert fillers[1].text == "uh"
+        assert fillers[2].text == "like"
+    
+    def test_detect_fillers_case_insensitive(self):
+        from ai_video_editor.models import TranscriptResult, Word
+        from ai_video_editor.heuristics import detect_fillers
+        
+        transcript = TranscriptResult(
+            text="UM this is UH important",
+            words=[
+                Word(text="UM", start=0.0, end=0.3),
+                Word(text="this", start=0.4, end=0.6),
+                Word(text="is", start=0.6, end=0.8),
+                Word(text="UH", start=0.9, end=1.1),
+                Word(text="important", start=1.2, end=1.6),
+            ],
+            duration=1.6
+        )
+        
+        fillers = detect_fillers(transcript, ["um", "uh"])
+        assert len(fillers) == 2
+
+
+class TestRepetitionDetection:
+    """Test repetition detection."""
+    
+    def test_detect_repetitions(self):
+        from ai_video_editor.models import TranscriptResult, Word
+        from ai_video_editor.heuristics import detect_repetitions
+        
+        transcript = TranscriptResult(
+            text="I think I think this is good",
+            words=[
+                Word(text="I", start=0.0, end=0.1),
+                Word(text="think", start=0.1, end=0.4),
+                Word(text="I", start=0.5, end=0.6),
+                Word(text="think", start=0.6, end=0.9),
+                Word(text="this", start=1.0, end=1.2),
+                Word(text="is", start=1.2, end=1.4),
+                Word(text="good", start=1.4, end=1.7),
+            ],
+            duration=1.7
+        )
+        
+        repetitions = detect_repetitions(transcript, window_size=5, min_repeat_words=2)
+        assert len(repetitions) >= 1
+
+
+class TestSilenceDetection:
+    """Test silence detection."""
+    
+    def test_detect_silence(self):
+        from ai_video_editor.models import TranscriptResult, Word
+        from ai_video_editor.heuristics import detect_silence
+        
+        transcript = TranscriptResult(
+            text="Hello world",
+            words=[
+                Word(text="Hello", start=0.0, end=0.5),
+                Word(text="world", start=2.0, end=2.5),
+            ],
+            duration=2.5
+        )
+        
+        silences = detect_silence(transcript, threshold_ms=1000)
+        assert len(silences) == 1
+        assert silences[0].start == 0.5
+        assert silences[0].end == 2.0
+    
+    def test_no_silence_below_threshold(self):
+        from ai_video_editor.models import TranscriptResult, Word
+        from ai_video_editor.heuristics import detect_silence
+        
+        transcript = TranscriptResult(
+            text="Hello world",
+            words=[
+                Word(text="Hello", start=0.0, end=0.5),
+                Word(text="world", start=0.8, end=1.3),
+            ],
+            duration=1.3
+        )
+        
+        silences = detect_silence(transcript, threshold_ms=700)
+        assert len(silences) == 0
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

agent_recipes/templates/ai-video-editor/tests/test_models.py

@@ -0,0 +1,152 @@
+"""
+Unit tests for AI Video Editor models.
+"""
+
+import sys
+import os
+from pathlib import Path
+
+# Add src to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+import pytest
+
+
+class TestWord:
+    """Test Word model."""
+    
+    def test_word_serialization(self):
+        from ai_video_editor.models import Word
+        
+        word = Word(text="hello", start=1.0, end=1.5, confidence=0.95)
+        data = word.to_dict()
+        
+        assert data["text"] == "hello"
+        assert data["start"] == 1.0
+        assert data["end"] == 1.5
+        assert data["confidence"] == 0.95
+        
+        word2 = Word.from_dict(data)
+        assert word2.text == word.text
+        assert word2.start == word.start
+
+
+class TestSegment:
+    """Test Segment model."""
+    
+    def test_segment_duration(self):
+        from ai_video_editor.models import Segment, SegmentCategory
+        
+        seg = Segment(start=10.0, end=15.5, category=SegmentCategory.KEEP)
+        assert seg.duration == 5.5
+    
+    def test_segment_serialization(self):
+        from ai_video_editor.models import Segment, SegmentCategory
+        
+        seg = Segment(
+            start=0.0,
+            end=10.0,
+            category=SegmentCategory.FILLER,
+            reason="um",
+            text="um"
+        )
+        
+        data = seg.to_dict()
+        assert data["category"] == "filler"
+        
+        seg2 = Segment.from_dict(data)
+        assert seg2.category == SegmentCategory.FILLER
+
+
+class TestEditPlan:
+    """Test EditPlan model."""
+    
+    def test_edit_plan_stats(self):
+        from ai_video_editor.models import EditPlan, Segment, SegmentCategory
+        
+        plan = EditPlan(
+            segments_to_keep=[
+                Segment(start=0, end=10, category=SegmentCategory.KEEP),
+                Segment(start=15, end=25, category=SegmentCategory.KEEP),
+            ],
+            segments_to_remove=[
+                Segment(start=10, end=12, category=SegmentCategory.FILLER),
+                Segment(start=12, end=15, category=SegmentCategory.SILENCE),
+            ]
+        )
+        
+        assert plan.total_keep_duration == 20.0
+        assert plan.total_remove_duration == 5.0
+        
+        stats = plan.removal_stats
+        assert stats["filler"] == 2.0
+        assert stats["silence"] == 3.0
+    
+    def test_edit_plan_json(self, tmp_path):
+        from ai_video_editor.models import EditPlan, Segment, SegmentCategory
+        
+        plan = EditPlan(
+            segments_to_keep=[
+                Segment(start=0, end=10, category=SegmentCategory.KEEP, reason="intro"),
+            ],
+            summary="Test video",
+            topics=["testing"]
+        )
+        
+        json_path = tmp_path / "plan.json"
+        plan.to_json(json_path)
+        
+        plan2 = EditPlan.from_json(json_path)
+        assert plan2.summary == "Test video"
+        assert len(plan2.segments_to_keep) == 1
+        assert plan2.topics == ["testing"]
+
+
+class TestTranscriptResult:
+    """Test TranscriptResult model."""
+    
+    def test_transcript_to_srt(self, tmp_path):
+        from ai_video_editor.models import TranscriptResult, Word
+        
+        transcript = TranscriptResult(
+            text="Hello world this is a test",
+            words=[
+                Word(text="Hello", start=0.0, end=0.5),
+                Word(text="world", start=0.5, end=1.0),
+                Word(text="this", start=1.0, end=1.3),
+                Word(text="is", start=1.3, end=1.5),
+                Word(text="a", start=1.5, end=1.6),
+                Word(text="test", start=1.6, end=2.0),
+            ],
+            duration=2.0
+        )
+        
+        srt_path = tmp_path / "captions.srt"
+        srt_content = transcript.to_srt(srt_path)
+        
+        assert srt_path.exists()
+        assert "Hello world this is a test" in srt_content
+        assert "-->" in srt_content
+
+
+class TestPresets:
+    """Test preset configurations."""
+    
+    def test_presets_exist(self):
+        from ai_video_editor.config import PRESETS
+        
+        assert "podcast" in PRESETS
+        assert "meeting" in PRESETS
+        assert "course" in PRESETS
+        assert "clean" in PRESETS
+    
+    def test_podcast_preset(self):
+        from ai_video_editor.config import PRESETS
+        
+        podcast = PRESETS["podcast"]
+        assert podcast["remove_fillers"] is True
+        assert "um" in podcast["filler_words"]
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

agent_recipes/templates/ai-video-editor/tests/test_timeline.py

@@ -0,0 +1,105 @@
+"""
+Unit tests for timeline optimization.
+"""
+
+import sys
+from pathlib import Path
+
+# Add src to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+import pytest
+
+
+class TestTimelineOptimization:
+    """Test timeline optimization functions."""
+    
+    def test_merge_overlapping_segments(self):
+        from ai_video_editor.models import Segment, SegmentCategory
+        from ai_video_editor.timeline import _merge_overlapping
+        
+        segments = [
+            Segment(start=0, end=10, category=SegmentCategory.KEEP),
+            Segment(start=8, end=15, category=SegmentCategory.KEEP),
+            Segment(start=20, end=25, category=SegmentCategory.KEEP),
+        ]
+        
+        merged = _merge_overlapping(segments)
+        
+        assert len(merged) == 2
+        assert merged[0].start == 0
+        assert merged[0].end == 15
+        assert merged[1].start == 20
+    
+    def test_get_keep_intervals(self):
+        from ai_video_editor.models import EditPlan, Segment, SegmentCategory
+        from ai_video_editor.timeline import get_keep_intervals
+        
+        plan = EditPlan(
+            segments_to_keep=[
+                Segment(start=10, end=20, category=SegmentCategory.KEEP),
+                Segment(start=0, end=5, category=SegmentCategory.KEEP),
+            ]
+        )
+        
+        intervals = get_keep_intervals(plan)
+        
+        assert intervals[0] == (0, 5)
+        assert intervals[1] == (10, 20)
+    
+    def test_calculate_final_duration(self):
+        from ai_video_editor.models import EditPlan, Segment, SegmentCategory
+        from ai_video_editor.timeline import calculate_final_duration
+        
+        plan = EditPlan(
+            segments_to_keep=[
+                Segment(start=0, end=10, category=SegmentCategory.KEEP),
+                Segment(start=20, end=35, category=SegmentCategory.KEEP),
+            ]
+        )
+        
+        duration = calculate_final_duration(plan)
+        assert duration == 25.0
+
+
+class TestUtils:
+    """Test utility functions."""
+    
+    def test_format_duration(self):
+        from ai_video_editor.utils import format_duration
+        
+        assert format_duration(30) == "30s"
+        assert format_duration(90) == "1m 30s"
+        assert format_duration(3661) == "1h 1m 1s"
+    
+    def test_parse_duration(self):
+        from ai_video_editor.utils import parse_duration
+        
+        assert parse_duration("30s") == 30.0
+        assert parse_duration("5m") == 300.0
+        assert parse_duration("1h30m") == 5400.0
+        assert parse_duration("1h30m45s") == 5445.0
+        assert parse_duration("90") == 90.0
+    
+    def test_file_hash(self, tmp_path):
+        from ai_video_editor.utils import file_hash
+        
+        test_file = tmp_path / "test.txt"
+        test_file.write_text("hello world")
+        
+        hash1 = file_hash(str(test_file))
+        hash2 = file_hash(str(test_file))
+        
+        assert hash1 == hash2
+        assert len(hash1) == 64
+    
+    def test_check_ffmpeg(self):
+        from ai_video_editor.utils import check_ffmpeg
+        
+        available, msg = check_ffmpeg()
+        assert isinstance(available, bool)
+        assert isinstance(msg, str)
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

agent_recipes/templates/ai-video-editor/workflow.yaml

@@ -0,0 +1,51 @@
+name: AI Video Editor Workflow
+description: |
+  End-to-end AI video editing pipeline.
+  Uses praisonai_tools.video CLI for video processing.
+  
+  Tier 1: Shell orchestration via shell_tool
+  Tier 2/3: Native tools via praisonai_tools.video module
+
+process: sequential
+
+variables:
+  input: ""
+  output: ""
+  preset: "podcast"
+  verbose: "true"
+
+agents:
+  video_editor:
+    name: VideoEditor
+    role: Video Editor
+    goal: Edit videos using AI analysis
+    instructions: |
+      You are an AI video editor. Use the praisonai_tools.video CLI to process videos.
+      
+      Available commands:
+      - python -m praisonai_tools.video edit <input> --output <output> --preset <preset> -v
+      - python -m praisonai_tools.video probe <input>
+      - python -m praisonai_tools.video transcribe <input> --output transcript.srt
+      
+      Presets: podcast, meeting, course, clean
+    tools: [shell_tool]
+
+tasks:
+  - name: probe_video
+    agent: video_editor
+    description: |
+      Probe the input video to get metadata.
+      Run: python -m praisonai_tools.video probe "{input}"
+    expected_output: Video metadata (duration, resolution, fps, codec)
+
+  - name: edit_video
+    agent: video_editor
+    description: |
+      Edit the video using AI analysis.
+      Run: python -m praisonai_tools.video edit "{input}" --preset {preset} --output "{output}" -v
+    expected_output: |
+      Edited video with:
+      - Filler words removed
+      - Repetitions removed
+      - Silences trimmed
+      - Transcript and captions generated