agent-recipes 0.0.5__py3-none-any.whl

agent_recipes/templates/ai-daily-news-show/recipe.yaml

@@ -0,0 +1,103 @@
+name: ai-daily-news-show
+version: 1.0.0
+description: End-to-end pipeline orchestrator for daily AI news show production
+author: PraisonAI
+tags:
+  - orchestrator
+  - pipeline
+  - news
+  - video
+  - automation
+
+config:
+  human_approval: false
+  approval_stages:
+    - script_review
+    - final_review
+  max_stories: 3
+  output_formats:
+    - youtube_long
+    - youtube_short
+  auto_publish: false
+
+input:
+  type: object
+  properties:
+    date:
+      type: string
+    sources:
+      type: array
+    max_stories:
+      type: integer
+
+output:
+  type: object
+  properties:
+    bundle_path:
+      type: string
+    videos:
+      type: array
+    scripts:
+      type: array
+    logs:
+      type: string
+
+requires:
+  env:
+    - OPENAI_API_KEY
+  optional_env:
+    - TAVILY_API_KEY
+  external:
+    - ffmpeg
+
+workflow:
+  pipeline:
+    - stage: crawl
+      recipe: ai-news-crawler
+      description: Crawl AI news from multiple sources
+    - stage: dedupe
+      recipe: ai-news-deduper
+      description: Remove duplicates and cluster topics
+    - stage: rank
+      recipe: ai-signal-ranker
+      description: Rank by novelty, velocity, relevance
+    - stage: enrich
+      recipe: ai-context-enricher
+      description: Add background and context
+    - stage: select
+      description: Select top stories for the show
+      human_approval: true
+    - stage: script
+      recipe: ai-script-writer
+      description: Generate scripts for each story
+    - stage: capture
+      recipe: ai-screenshot-capture
+      description: Capture visuals from source pages
+    - stage: voiceover
+      recipe: ai-voiceover-generator
+      description: Generate voice overs
+    - stage: video
+      recipe: ai-broll-builder
+      description: Build B-roll from captures
+    - stage: merge
+      recipe: ai-video-merger
+      description: Merge voice and video
+    - stage: shorts
+      recipe: shorts-generator
+      description: Generate short-form clips
+    - stage: bundle
+      recipe: ai-publisher-pack
+      description: Create publisher packs
+    - stage: log
+      description: Log outputs and metrics
+
+  agents:
+    - name: orchestrator
+      role: Pipeline Orchestrator
+      goal: Coordinate the daily news show production pipeline
+      backstory: Expert at managing complex content production workflows
+      tools:
+        - run_pipeline
+        - check_stage_status
+        - request_approval
+        - bundle_outputs

agent_recipes/templates/ai-daily-news-show/tools.py

@@ -0,0 +1,308 @@
+"""
+AI Daily News Show Tools
+
+End-to-end pipeline orchestrator for daily AI news show production.
+Coordinates: crawl → rank → select → scripts → capture → voice → video → shorts → bundle
+"""
+
+import json
+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 run_pipeline(
+    date: Optional[str] = None,
+    sources: Optional[List[str]] = None,
+    max_stories: int = 3,
+    human_approval: bool = False,
+    output_dir: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Run the complete daily news show pipeline.
+    
+    Args:
+        date: Date for the show (default: today)
+        sources: News sources to crawl
+        max_stories: Maximum stories to include
+        human_approval: Require human approval at key stages
+        output_dir: Output directory
+        
+    Returns:
+        Pipeline results with all outputs
+    """
+    date = date or datetime.now().strftime("%Y-%m-%d")
+    sources = sources or ["hackernews", "reddit", "arxiv"]
+    output_dir = output_dir or f"./daily_show_{date.replace('-', '')}"
+    
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+    
+    pipeline_log = {
+        "date": date,
+        "started_at": datetime.now(timezone.utc).isoformat(),
+        "stages": [],
+        "status": "running",
+    }
+    
+    try:
+        # Stage 1: Crawl
+        logger.info("Stage 1: Crawling news sources...")
+        from agent_recipes.templates.ai_news_crawler import tools as crawler
+        crawl_result = crawler.crawl_ai_news(sources=sources, max_articles=50)
+        articles = crawl_result.get("articles", [])
+        pipeline_log["stages"].append({"stage": "crawl", "status": "complete", "articles": len(articles)})
+        
+        # Stage 2: Dedupe
+        logger.info("Stage 2: Deduplicating articles...")
+        from agent_recipes.templates.ai_news_deduper import tools as deduper
+        dedup_result = deduper.deduplicate_articles(articles, use_semantic=False)
+        articles = dedup_result.get("deduplicated", articles)
+        pipeline_log["stages"].append({"stage": "dedupe", "status": "complete", "remaining": len(articles)})
+        
+        # Stage 3: Rank
+        logger.info("Stage 3: Ranking articles...")
+        from agent_recipes.templates.ai_signal_ranker import tools as ranker
+        rank_result = ranker.rank_articles(articles, top_n=max_stories * 2)
+        articles = rank_result.get("ranked_articles", articles)
+        pipeline_log["stages"].append({"stage": "rank", "status": "complete"})
+        
+        # Stage 4: Select top stories
+        logger.info(f"Stage 4: Selecting top {max_stories} stories...")
+        selected = articles[:max_stories]
+        
+        if human_approval:
+            # Save for human review
+            review_path = os.path.join(output_dir, "stories_for_review.json")
+            with open(review_path, "w") as f:
+                json.dump(selected, f, indent=2)
+            pipeline_log["stages"].append({"stage": "select", "status": "awaiting_approval", "path": review_path})
+            pipeline_log["status"] = "awaiting_approval"
+            return {"pipeline_log": pipeline_log, "awaiting_approval": True}
+        
+        pipeline_log["stages"].append({"stage": "select", "status": "complete", "selected": len(selected)})
+        
+        # Stage 5: Generate scripts
+        logger.info("Stage 5: Generating scripts...")
+        scripts = []
+        from agent_recipes.templates.ai_script_writer import tools as writer
+        
+        for i, story in enumerate(selected):
+            script_result = writer.write_youtube_script(
+                topic=story.get("title", "AI News"),
+                target_length=180,
+                key_points=[story.get("content", "")[:200]],
+            )
+            scripts.append({
+                "story_index": i,
+                "title": story.get("title"),
+                "script": script_result.get("script", ""),
+            })
+            
+            # Save script
+            script_path = os.path.join(output_dir, f"script_{i}.md")
+            with open(script_path, "w") as f:
+                f.write(f"# {story.get('title')}\n\n{script_result.get('script', '')}")
+        
+        pipeline_log["stages"].append({"stage": "script", "status": "complete", "scripts": len(scripts)})
+        
+        # Stage 6: Generate voiceovers
+        logger.info("Stage 6: Generating voiceovers...")
+        voiceovers = []
+        from agent_recipes.templates.ai_voiceover_generator import tools as voice
+        
+        for i, script in enumerate(scripts):
+            vo_result = voice.generate_voiceover(
+                text=script.get("script", "")[:4000],
+                output_path=os.path.join(output_dir, f"voiceover_{i}.mp3"),
+            )
+            if "path" in vo_result:
+                voiceovers.append(vo_result["path"])
+        
+        pipeline_log["stages"].append({"stage": "voiceover", "status": "complete", "files": len(voiceovers)})
+        
+        # Stage 7: Bundle outputs
+        logger.info("Stage 7: Creating output bundle...")
+        bundle_result = bundle_outputs(
+            output_dir=output_dir,
+            scripts=scripts,
+            voiceovers=voiceovers,
+            articles=selected,
+        )
+        
+        pipeline_log["stages"].append({"stage": "bundle", "status": "complete"})
+        pipeline_log["status"] = "complete"
+        pipeline_log["completed_at"] = datetime.now(timezone.utc).isoformat()
+        
+        # Save pipeline log
+        log_path = os.path.join(output_dir, "pipeline_log.json")
+        with open(log_path, "w") as f:
+            json.dump(pipeline_log, f, indent=2)
+        
+        return {
+            "status": "complete",
+            "output_dir": output_dir,
+            "bundle": bundle_result,
+            "scripts": scripts,
+            "voiceovers": voiceovers,
+            "pipeline_log": pipeline_log,
+        }
+        
+    except Exception as e:
+        logger.error(f"Pipeline error: {e}")
+        pipeline_log["status"] = "failed"
+        pipeline_log["error"] = str(e)
+        return {"status": "failed", "error": str(e), "pipeline_log": pipeline_log}
+
+
+def check_stage_status(
+    output_dir: str,
+    stage: str,
+) -> Dict[str, Any]:
+    """
+    Check the status of a pipeline stage.
+    
+    Args:
+        output_dir: Pipeline output directory
+        stage: Stage name to check
+        
+    Returns:
+        Stage status
+    """
+    log_path = os.path.join(output_dir, "pipeline_log.json")
+    
+    if not os.path.exists(log_path):
+        return {"status": "not_found"}
+    
+    with open(log_path) as f:
+        log = json.load(f)
+    
+    for s in log.get("stages", []):
+        if s.get("stage") == stage:
+            return s
+    
+    return {"status": "not_started"}
+
+
+def request_approval(
+    output_dir: str,
+    stage: str,
+    items: List[Dict[str, Any]],
+) -> Dict[str, Any]:
+    """
+    Request human approval for a stage.
+    
+    Args:
+        output_dir: Pipeline output directory
+        stage: Stage requiring approval
+        items: Items to approve
+        
+    Returns:
+        Approval request info
+    """
+    approval_path = os.path.join(output_dir, f"approval_{stage}.json")
+    
+    approval_request = {
+        "stage": stage,
+        "requested_at": datetime.now(timezone.utc).isoformat(),
+        "items": items,
+        "status": "pending",
+    }
+    
+    with open(approval_path, "w") as f:
+        json.dump(approval_request, f, indent=2)
+    
+    return {
+        "approval_path": approval_path,
+        "status": "pending",
+        "items_count": len(items),
+    }
+
+
+def bundle_outputs(
+    output_dir: str,
+    scripts: List[Dict[str, Any]],
+    voiceovers: List[str],
+    articles: List[Dict[str, Any]],
+) -> Dict[str, Any]:
+    """
+    Bundle all pipeline outputs.
+    
+    Args:
+        output_dir: Output directory
+        scripts: Generated scripts
+        voiceovers: Voiceover file paths
+        articles: Source articles
+        
+    Returns:
+        Bundle info
+    """
+    bundle_manifest = {
+        "created_at": datetime.now(timezone.utc).isoformat(),
+        "scripts": [
+            {"index": s["story_index"], "title": s["title"]}
+            for s in scripts
+        ],
+        "voiceovers": voiceovers,
+        "articles": [
+            {"title": a.get("title"), "url": a.get("url"), "source": a.get("source")}
+            for a in articles
+        ],
+    }
+    
+    manifest_path = os.path.join(output_dir, "bundle_manifest.json")
+    with open(manifest_path, "w") as f:
+        json.dump(bundle_manifest, f, indent=2)
+    
+    return {
+        "manifest_path": manifest_path,
+        "output_dir": output_dir,
+        "total_scripts": len(scripts),
+        "total_voiceovers": len(voiceovers),
+    }
+
+
+def resume_pipeline(
+    output_dir: str,
+    approved_items: Optional[List[int]] = None,
+) -> Dict[str, Any]:
+    """
+    Resume a pipeline after human approval.
+    
+    Args:
+        output_dir: Pipeline output directory
+        approved_items: Indices of approved items
+        
+    Returns:
+        Resumed pipeline results
+    """
+    log_path = os.path.join(output_dir, "pipeline_log.json")
+    
+    if not os.path.exists(log_path):
+        return {"error": "Pipeline log not found"}
+    
+    with open(log_path) as f:
+        log = json.load(f)
+    
+    if log.get("status") != "awaiting_approval":
+        return {"error": "Pipeline not awaiting approval"}
+    
+    # Load stories for review
+    review_path = os.path.join(output_dir, "stories_for_review.json")
+    with open(review_path) as f:
+        stories = json.load(f)
+    
+    # Filter to approved items
+    if approved_items:
+        stories = [stories[i] for i in approved_items if i < len(stories)]
+    
+    # Continue pipeline from script generation
+    return run_pipeline(
+        date=log.get("date"),
+        max_stories=len(stories),
+        human_approval=False,
+        output_dir=output_dir,
+    )

agent_recipes/templates/ai-data-anonymizer/README.md

@@ -0,0 +1,60 @@
+# Data Anonymizer
+
+Anonymize PII in datasets (GDPR/CCPA-oriented)
+
+## Installation
+
+```bash
+pip install agent-recipes
+```
+
+## CLI Usage
+
+```bash
+# Basic usage
+praison recipes run ai-data-anonymizer <input>
+
+# With output directory
+praison recipes run ai-data-anonymizer <input> --output ./output/
+
+# Dry run (check dependencies only)
+praison recipes run ai-data-anonymizer <input> --dry-run
+
+# Show recipe info
+praison recipes info ai-data-anonymizer
+
+# Check dependencies
+praison recipes doctor ai-data-anonymizer
+```
+
+## Python Usage
+
+```python
+from praisonaiagents import Agent
+from agent_recipes import load_recipe
+
+# Load and run recipe
+recipe = load_recipe("ai-data-anonymizer")
+result = recipe.run(input="<your-input>")
+print(result)
+```
+
+## Requirements
+
+### Packages
+- openai
+- pandas
+
+### Environment Variables
+- OPENAI_API_KEY
+
+### External Tools
+- None
+
+## Tags
+
+`data`, `privacy`, `anonymization`, `gdpr`
+
+## License
+
+Apache-2.0

agent_recipes/templates/ai-data-anonymizer/TEMPLATE.yaml

@@ -0,0 +1,31 @@
+name: ai-data-anonymizer
+version: "1.0.0"
+description: Anonymize PII in datasets (GDPR/CCPA-oriented)
+author: praison
+license: Apache-2.0
+tags:
+  - data
+  - privacy
+  - anonymization
+  - gdpr
+
+requires:
+  tools:
+    - data_tool
+    - llm_tool
+  packages:
+    - openai
+    - pandas
+  env:
+    - OPENAI_API_KEY
+
+cli:
+  command: praison recipes run ai-data-anonymizer
+  examples:
+    - praison recipes run ai-data-anonymizer <input>
+    - praison recipes run ai-data-anonymizer <input> --output ./output/
+    - praison recipes run ai-data-anonymizer <input> --dry-run
+
+safety:
+  dry_run_default: true
+  overwrites_files: true

agent_recipes/templates/ai-data-profiler/README.md

@@ -0,0 +1,14 @@
+# AI Data Profiler
+
+Profile data files with statistics and quality metrics.
+
+## Usage
+```bash
+praison run ai-data-profiler data.csv
+praison run ai-data-profiler data.json --sample 1000
+```
+
+## Output
+- `profile-report.html` - Visual report
+- `stats.json` - Column statistics
+- `quality.json` - Data quality metrics

agent_recipes/templates/ai-data-profiler/TEMPLATE.yaml

@@ -0,0 +1,42 @@
+name: ai-data-profiler
+version: "1.0.0"
+description: Profile data files with statistics and quality metrics.
+author: praisonai
+license: Apache-2.0
+tags: [data, profiling, statistics, quality]
+
+requires:
+  tools: [shell_tool]
+  packages: [praisonai-tools, pandas]
+  env: [OPENAI_API_KEY]
+
+config:
+  input:
+    type: string
+    required: true
+  output:
+    type: string
+  sample:
+    type: integer
+
+cli:
+  command: ai-data-profiler
+  args:
+    - name: input
+      positional: true
+      required: true
+    - name: --output
+      short: -o
+    - name: --sample
+  examples:
+    - "praison run ai-data-profiler data.csv"
+
+outputs:
+  - name: profile-report.html
+    type: file
+  - name: stats.json
+    type: file
+  - name: quality.json
+    type: file
+  - name: run.json
+    type: file

agent_recipes/templates/ai-dependency-auditor/README.md

@@ -0,0 +1,12 @@
+# AI Dependency Auditor
+
+Audit project dependencies for updates and vulnerabilities.
+
+## Usage
+```bash
+praison run ai-dependency-auditor ./my-project
+```
+
+## Output
+- `audit-report.md` - Audit findings
+- `updates.json` - Available updates

agent_recipes/templates/ai-dependency-auditor/TEMPLATE.yaml

@@ -0,0 +1,37 @@
+name: ai-dependency-auditor
+version: "1.0.0"
+description: Audit project dependencies for updates and vulnerabilities.
+author: praisonai
+license: Apache-2.0
+tags: [dependencies, security, audit, updates]
+
+requires:
+  tools: [shell_tool]
+  packages: [praisonai-tools]
+  env: [OPENAI_API_KEY]
+
+config:
+  input:
+    type: string
+    required: true
+  output:
+    type: string
+
+cli:
+  command: ai-dependency-auditor
+  args:
+    - name: input
+      positional: true
+      required: true
+    - name: --output
+      short: -o
+  examples:
+    - "praison run ai-dependency-auditor ./my-project"
+
+outputs:
+  - name: audit-report.md
+    type: file
+  - name: updates.json
+    type: file
+  - name: run.json
+    type: file

agent_recipes/templates/ai-doc-translator/README.md

@@ -0,0 +1,12 @@
+# AI Doc Translator
+
+Translate documents to different languages.
+
+## Usage
+```bash
+praison run ai-doc-translator document.md --language es
+praison run ai-doc-translator document.txt --language fr
+```
+
+## Output
+- `translated.md` - Translated document

agent_recipes/templates/ai-doc-translator/TEMPLATE.yaml

@@ -0,0 +1,41 @@
+name: ai-doc-translator
+version: "1.0.0"
+description: Translate documents to different languages.
+author: praisonai
+license: Apache-2.0
+tags: [translation, document, language]
+
+requires:
+  tools: [shell_tool]
+  packages: [praisonai-tools]
+  env: [OPENAI_API_KEY]
+
+config:
+  input:
+    type: string
+    required: true
+  output:
+    type: string
+  target_language:
+    type: string
+    default: "en"
+
+cli:
+  command: ai-doc-translator
+  args:
+    - name: input
+      positional: true
+      required: true
+    - name: --output
+      short: -o
+    - name: --language
+      short: -l
+      default: "en"
+  examples:
+    - "praison run ai-doc-translator document.md --language es"
+
+outputs:
+  - name: translated.md
+    type: file
+  - name: run.json
+    type: file