agent-recipes 0.0.5__py3-none-any.whl

agent_recipes/templates/ai-screenshot-capture/tools.py

@@ -0,0 +1,231 @@
+"""
+AI Screenshot Capture Tools
+
+High-resolution screenshot capture with:
+- Full page capture
+- Element highlighting
+- Auto-scroll
+- Multiple format support
+"""
+
+import logging
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def capture_screenshot(
+    url: str,
+    output_path: Optional[str] = None,
+    width: int = 1920,
+    height: int = 1080,
+    full_page: bool = False,
+    quality: int = 95,
+) -> Dict[str, Any]:
+    """
+    Capture a screenshot of a URL.
+    
+    Args:
+        url: URL to capture
+        output_path: Path to save screenshot
+        width: Viewport width
+        height: Viewport height
+        full_page: Capture full page
+        quality: Image quality (1-100)
+        
+    Returns:
+        Dictionary with screenshot info
+    """
+    try:
+        from playwright.sync_api import sync_playwright
+    except ImportError:
+        logger.error("Playwright not installed. Run: pip install playwright && playwright install")
+        return {"error": "Playwright not installed"}
+    
+    if not output_path:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        output_path = f"screenshot_{timestamp}.png"
+    
+    try:
+        with sync_playwright() as p:
+            browser = p.chromium.launch(headless=True)
+            page = browser.new_page(viewport={"width": width, "height": height})
+            page.goto(url, wait_until="networkidle")
+            
+            page.screenshot(
+                path=output_path,
+                full_page=full_page,
+                quality=quality if output_path.endswith(".jpg") else None,
+            )
+            
+            browser.close()
+        
+        return {
+            "path": output_path,
+            "url": url,
+            "width": width,
+            "height": height,
+            "full_page": full_page,
+            "captured_at": datetime.now(timezone.utc).isoformat(),
+        }
+        
+    except Exception as e:
+        logger.error(f"Error capturing screenshot: {e}")
+        return {"error": str(e)}
+
+
+def capture_full_page(
+    url: str,
+    output_dir: Optional[str] = None,
+    scroll_delay: float = 0.5,
+) -> Dict[str, Any]:
+    """
+    Capture full page with auto-scroll.
+    
+    Args:
+        url: URL to capture
+        output_dir: Directory to save screenshots
+        scroll_delay: Delay between scrolls
+        
+    Returns:
+        Dictionary with capture info
+    """
+    output_dir = output_dir or "./screenshots"
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    output_path = os.path.join(output_dir, f"fullpage_{timestamp}.png")
+    
+    return capture_screenshot(url, output_path, full_page=True)
+
+
+def highlight_and_capture(
+    url: str,
+    selectors: List[str],
+    output_dir: Optional[str] = None,
+    highlight_color: str = "yellow",
+) -> Dict[str, Any]:
+    """
+    Highlight elements and capture screenshots.
+    
+    Args:
+        url: URL to capture
+        selectors: CSS selectors to highlight
+        output_dir: Directory to save screenshots
+        highlight_color: Highlight color
+        
+    Returns:
+        Dictionary with captures
+    """
+    try:
+        from playwright.sync_api import sync_playwright
+    except ImportError:
+        return {"error": "Playwright not installed"}
+    
+    output_dir = output_dir or "./screenshots"
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    
+    captures = []
+    
+    try:
+        with sync_playwright() as p:
+            browser = p.chromium.launch(headless=True)
+            page = browser.new_page(viewport={"width": 1920, "height": 1080})
+            page.goto(url, wait_until="networkidle")
+            
+            for i, selector in enumerate(selectors):
+                try:
+                    # Add highlight style
+                    page.evaluate(f"""
+                        const el = document.querySelector('{selector}');
+                        if (el) {{
+                            el.style.backgroundColor = '{highlight_color}';
+                            el.style.outline = '3px solid red';
+                        }}
+                    """)
+                    
+                    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                    output_path = os.path.join(output_dir, f"highlight_{i}_{timestamp}.png")
+                    
+                    page.screenshot(path=output_path)
+                    
+                    captures.append({
+                        "path": output_path,
+                        "selector": selector,
+                    })
+                    
+                    # Remove highlight
+                    page.evaluate(f"""
+                        const el = document.querySelector('{selector}');
+                        if (el) {{
+                            el.style.backgroundColor = '';
+                            el.style.outline = '';
+                        }}
+                    """)
+                    
+                except Exception as e:
+                    logger.warning(f"Error highlighting {selector}: {e}")
+            
+            browser.close()
+        
+        return {
+            "captures": captures,
+            "url": url,
+            "total": len(captures),
+        }
+        
+    except Exception as e:
+        logger.error(f"Error in highlight capture: {e}")
+        return {"error": str(e)}
+
+
+def bundle_captures(
+    captures: List[Dict[str, Any]],
+    output_dir: str,
+    bundle_name: str = "capture_pack",
+) -> Dict[str, Any]:
+    """
+    Bundle multiple captures into a pack.
+    
+    Args:
+        captures: List of capture dictionaries
+        output_dir: Output directory
+        bundle_name: Name for the bundle
+        
+    Returns:
+        Bundle info
+    """
+    import json
+    import shutil
+    
+    bundle_dir = os.path.join(output_dir, bundle_name)
+    Path(bundle_dir).mkdir(parents=True, exist_ok=True)
+    
+    manifest = {
+        "name": bundle_name,
+        "created_at": datetime.now(timezone.utc).isoformat(),
+        "files": [],
+    }
+    
+    for capture in captures:
+        if "path" in capture and os.path.exists(capture["path"]):
+            filename = os.path.basename(capture["path"])
+            dest = os.path.join(bundle_dir, filename)
+            shutil.copy2(capture["path"], dest)
+            manifest["files"].append({
+                "filename": filename,
+                "original": capture.get("url", ""),
+            })
+    
+    manifest_path = os.path.join(bundle_dir, "manifest.json")
+    with open(manifest_path, "w") as f:
+        json.dump(manifest, f, indent=2)
+    
+    return {
+        "bundle_dir": bundle_dir,
+        "manifest": manifest,
+        "file_count": len(manifest["files"]),
+    }

agent_recipes/templates/ai-screenshot-ocr/README.md

@@ -0,0 +1,12 @@
+# AI Screenshot OCR
+
+Extract text from screenshots using OCR.
+
+## Usage
+```bash
+praison run ai-screenshot-ocr screenshot.png
+```
+
+## Output
+- `extracted-text.md` - Extracted text
+- `structured.json` - Structured data

agent_recipes/templates/ai-screenshot-ocr/TEMPLATE.yaml

@@ -0,0 +1,37 @@
+name: ai-screenshot-ocr
+version: "1.0.0"
+description: Extract text from screenshots using OCR.
+author: praisonai
+license: Apache-2.0
+tags: [screenshot, ocr, text-extraction]
+
+requires:
+  tools: [shell_tool]
+  packages: [praisonai-tools]
+  env: [OPENAI_API_KEY]
+
+config:
+  input:
+    type: string
+    required: true
+  output:
+    type: string
+
+cli:
+  command: ai-screenshot-ocr
+  args:
+    - name: input
+      positional: true
+      required: true
+    - name: --output
+      short: -o
+  examples:
+    - "praison run ai-screenshot-ocr screenshot.png"
+
+outputs:
+  - name: extracted-text.md
+    type: file
+  - name: structured.json
+    type: file
+  - name: run.json
+    type: file

agent_recipes/templates/ai-script-writer/recipe.yaml

@@ -0,0 +1,58 @@
+name: ai-script-writer
+version: 1.0.0
+description: Multi-format script writer for YouTube long/short, X threads, LinkedIn posts, and image captions
+author: PraisonAI
+tags:
+  - script
+  - content
+  - youtube
+  - social-media
+
+config:
+  formats:
+    - youtube_long
+    - youtube_short
+    - x_thread
+    - linkedin
+    - image_caption
+    - hook_30s
+  default_tone: educational
+  include_timestamps: true
+
+input:
+  type: object
+  properties:
+    topic:
+      type: string
+    format:
+      type: string
+      enum: [youtube_long, youtube_short, x_thread, linkedin, image_caption, hook_30s]
+    target_length:
+      type: integer
+    tone:
+      type: string
+    key_points:
+      type: array
+
+output:
+  type: object
+  properties:
+    script:
+      type: string
+    metadata:
+      type: object
+
+requires:
+  env:
+    - OPENAI_API_KEY
+
+workflow:
+  agents:
+    - name: script_writer
+      role: Content Script Writer
+      goal: Create engaging scripts for multiple platforms
+      tools:
+        - write_youtube_script
+        - write_short_script
+        - write_thread
+        - write_linkedin_post

agent_recipes/templates/ai-script-writer/tools.py

@@ -0,0 +1,297 @@
+"""
+AI Script Writer Tools
+
+Multi-format script generation for:
+- YouTube long-form (10+ min)
+- YouTube Shorts (60s)
+- 30-second hooks
+- X/Twitter threads
+- LinkedIn posts
+- Image captions
+"""
+
+import logging
+import os
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def call_llm(prompt: str, max_tokens: int = 2000) -> str:
+    """Call OpenAI API for text generation."""
+    import requests
+    
+    api_key = os.environ.get("OPENAI_API_KEY")
+    if not api_key:
+        raise ValueError("OPENAI_API_KEY not set")
+    
+    response = requests.post(
+        "https://api.openai.com/v1/chat/completions",
+        headers={
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+        },
+        json={
+            "model": "gpt-4o-mini",
+            "messages": [{"role": "user", "content": prompt}],
+            "max_tokens": max_tokens,
+            "temperature": 0.8,
+        },
+        timeout=120,
+    )
+    response.raise_for_status()
+    return response.json()["choices"][0]["message"]["content"]
+
+
+def write_youtube_script(
+    topic: str,
+    target_length: int = 600,
+    tone: str = "educational",
+    key_points: Optional[List[str]] = None,
+    include_timestamps: bool = True,
+) -> Dict[str, Any]:
+    """
+    Write a YouTube long-form video script.
+    
+    Args:
+        topic: Video topic
+        target_length: Target length in seconds
+        tone: Script tone (educational, entertaining, professional)
+        key_points: Key points to cover
+        include_timestamps: Include timestamp markers
+        
+    Returns:
+        Script with metadata
+    """
+    key_points_text = "\n".join(f"- {p}" for p in (key_points or []))
+    
+    prompt = f"""Write a YouTube video script about: {topic}
+
+Target length: {target_length} seconds (~{target_length // 60} minutes)
+Tone: {tone}
+Key points to cover:
+{key_points_text if key_points_text else "- Cover the main aspects of the topic"}
+
+Structure the script with:
+1. Hook (first 10 seconds) - grab attention immediately
+2. Introduction - what viewers will learn
+3. Main content - organized sections with clear transitions
+4. Call to action - subscribe, comment, etc.
+5. Outro
+
+{"Include [TIMESTAMP: MM:SS] markers for each section." if include_timestamps else ""}
+
+Write in a conversational, engaging style suitable for YouTube."""
+    
+    script = call_llm(prompt, max_tokens=3000)
+    
+    return {
+        "script": script,
+        "format": "youtube_long",
+        "metadata": {
+            "topic": topic,
+            "target_length": target_length,
+            "tone": tone,
+            "word_count": len(script.split()),
+        }
+    }
+
+
+def write_short_script(
+    topic: str,
+    duration: int = 60,
+    style: str = "hook_first",
+) -> Dict[str, Any]:
+    """
+    Write a YouTube Shorts / TikTok / Reels script.
+    
+    Args:
+        topic: Video topic
+        duration: Duration in seconds (30 or 60)
+        style: Script style (hook_first, story, listicle)
+        
+    Returns:
+        Script with metadata
+    """
+    prompt = f"""Write a {duration}-second short-form video script about: {topic}
+
+Style: {style}
+Platform: YouTube Shorts / TikTok / Reels
+
+Requirements:
+- Start with an attention-grabbing hook (first 2 seconds)
+- Keep it punchy and fast-paced
+- One clear message or takeaway
+- End with a call to action or cliffhanger
+
+Format:
+[HOOK - 0:00]
+(script)
+
+[MAIN - 0:03]
+(script)
+
+[CTA - 0:{duration-5}]
+(script)"""
+    
+    script = call_llm(prompt, max_tokens=500)
+    
+    return {
+        "script": script,
+        "format": "youtube_short",
+        "metadata": {
+            "topic": topic,
+            "duration": duration,
+            "style": style,
+        }
+    }
+
+
+def write_thread(
+    topic: str,
+    num_tweets: int = 7,
+    include_hook: bool = True,
+) -> Dict[str, Any]:
+    """
+    Write an X/Twitter thread.
+    
+    Args:
+        topic: Thread topic
+        num_tweets: Number of tweets in thread
+        include_hook: Include a hook tweet
+        
+    Returns:
+        Thread with metadata
+    """
+    prompt = f"""Write a Twitter/X thread about: {topic}
+
+Number of tweets: {num_tweets}
+
+Requirements:
+- Tweet 1: Strong hook that makes people want to read more
+- Each tweet: Max 280 characters
+- Use thread numbering (1/, 2/, etc.)
+- Include a mix of insights, examples, and actionable tips
+- Last tweet: Call to action (follow, retweet, etc.)
+
+Format each tweet on its own line with the number prefix."""
+    
+    script = call_llm(prompt, max_tokens=1500)
+    
+    return {
+        "script": script,
+        "format": "x_thread",
+        "metadata": {
+            "topic": topic,
+            "num_tweets": num_tweets,
+        }
+    }
+
+
+def write_linkedin_post(
+    topic: str,
+    style: str = "thought_leadership",
+    include_emoji: bool = True,
+) -> Dict[str, Any]:
+    """
+    Write a LinkedIn post.
+    
+    Args:
+        topic: Post topic
+        style: Post style (thought_leadership, story, tips, announcement)
+        include_emoji: Include emojis
+        
+    Returns:
+        Post with metadata
+    """
+    prompt = f"""Write a LinkedIn post about: {topic}
+
+Style: {style}
+{"Include relevant emojis to break up text and add visual interest." if include_emoji else "No emojis."}
+
+Requirements:
+- Strong opening line (this shows in preview)
+- Use line breaks for readability
+- Include a personal angle or story
+- End with a question to drive engagement
+- Keep under 1300 characters for optimal engagement
+
+Format for LinkedIn (short paragraphs, line breaks between sections)."""
+    
+    script = call_llm(prompt, max_tokens=800)
+    
+    return {
+        "script": script,
+        "format": "linkedin",
+        "metadata": {
+            "topic": topic,
+            "style": style,
+        }
+    }
+
+
+def write_image_caption(
+    topic: str,
+    platform: str = "instagram",
+    include_hashtags: bool = True,
+) -> Dict[str, Any]:
+    """
+    Write an image caption for social media.
+    
+    Args:
+        topic: Caption topic/context
+        platform: Target platform
+        include_hashtags: Include hashtags
+        
+    Returns:
+        Caption with metadata
+    """
+    prompt = f"""Write a {platform} image caption about: {topic}
+
+Requirements:
+- Engaging first line (shows in preview)
+- Conversational tone
+- Call to action
+{"- Include 5-10 relevant hashtags at the end" if include_hashtags else ""}
+
+Keep it concise but engaging."""
+    
+    script = call_llm(prompt, max_tokens=300)
+    
+    return {
+        "script": script,
+        "format": "image_caption",
+        "metadata": {
+            "topic": topic,
+            "platform": platform,
+        }
+    }
+
+
+def write_script(
+    topic: str,
+    format: str = "youtube_long",
+    **kwargs,
+) -> Dict[str, Any]:
+    """
+    Main entry point for script writing.
+    
+    Args:
+        topic: Content topic
+        format: Output format
+        **kwargs: Format-specific options
+        
+    Returns:
+        Script with metadata
+    """
+    format_handlers = {
+        "youtube_long": write_youtube_script,
+        "youtube_short": write_short_script,
+        "x_thread": write_thread,
+        "linkedin": write_linkedin_post,
+        "image_caption": write_image_caption,
+        "hook_30s": lambda t, **kw: write_short_script(t, duration=30, **kw),
+    }
+    
+    handler = format_handlers.get(format, write_youtube_script)
+    return handler(topic, **kwargs)

agent_recipes/templates/ai-sentiment-analyzer/README.md

@@ -0,0 +1,59 @@
+# Sentiment Analyzer
+
+Analyze sentiment in text data
+
+## Installation
+
+```bash
+pip install agent-recipes
+```
+
+## CLI Usage
+
+```bash
+# Basic usage
+praison recipes run ai-sentiment-analyzer <input>
+
+# With output directory
+praison recipes run ai-sentiment-analyzer <input> --output ./output/
+
+# Dry run (check dependencies only)
+praison recipes run ai-sentiment-analyzer <input> --dry-run
+
+# Show recipe info
+praison recipes info ai-sentiment-analyzer
+
+# Check dependencies
+praison recipes doctor ai-sentiment-analyzer
+```
+
+## Python Usage
+
+```python
+from praisonaiagents import Agent
+from agent_recipes import load_recipe
+
+# Load and run recipe
+recipe = load_recipe("ai-sentiment-analyzer")
+result = recipe.run(input="<your-input>")
+print(result)
+```
+
+## Requirements
+
+### Packages
+- openai
+
+### Environment Variables
+- OPENAI_API_KEY
+
+### External Tools
+- None
+
+## Tags
+
+`data`, `sentiment`, `nlp`
+
+## License
+
+Apache-2.0