@heylemon/lemonade 0.2.4 → 0.2.5

package/skills/openai-image-gen/scripts/gen.py

@@ -1,255 +0,0 @@
-#!/usr/bin/env python3
-import argparse
-import base64
-import datetime as dt
-import json
-import os
-import random
-import re
-import sys
-import urllib.error
-import urllib.request
-from pathlib import Path
-
-
-def slugify(text: str) -> str:
-    text = text.lower().strip()
-    text = re.sub(r"[^a-z0-9]+", "-", text)
-    text = re.sub(r"-{2,}", "-", text).strip("-")
-    return text or "image"
-
-
-def default_out_dir() -> Path:
-    now = dt.datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
-    preferred = Path.home() / "Projects" / "tmp"
-    base = preferred if preferred.is_dir() else Path("./tmp")
-    base.mkdir(parents=True, exist_ok=True)
-    return base / f"openai-image-gen-{now}"
-
-
-def pick_prompts(count: int) -> list[str]:
-    subjects = [
-        "a lobster astronaut",
-        "a brutalist lighthouse",
-        "a cozy reading nook",
-        "a cyberpunk noodle shop",
-        "a Vienna street at dusk",
-        "a minimalist product photo",
-        "a surreal underwater library",
-    ]
-    styles = [
-        "ultra-detailed studio photo",
-        "35mm film still",
-        "isometric illustration",
-        "editorial photography",
-        "soft watercolor",
-        "architectural render",
-        "high-contrast monochrome",
-    ]
-    lighting = [
-        "golden hour",
-        "overcast soft light",
-        "neon lighting",
-        "dramatic rim light",
-        "candlelight",
-        "foggy atmosphere",
-    ]
-    prompts: list[str] = []
-    for _ in range(count):
-        prompts.append(
-            f"{random.choice(styles)} of {random.choice(subjects)}, {random.choice(lighting)}"
-        )
-    return prompts
-
-
-def get_model_defaults(model: str) -> tuple[str, str]:
-    """Return (default_size, default_quality) for the given model."""
-    if model == "dall-e-2":
-        # quality will be ignored
-        return ("1024x1024", "standard")
-    elif model == "dall-e-3":
-        return ("1024x1024", "standard")
-    else:
-        # GPT image or future models
-        return ("1024x1024", "high")
-
-
-def resolve_api_url_and_key() -> tuple[str, str]:
-    """Resolve the images API base URL and auth token.
-    Prefers the Lemonade backend proxy; falls back to direct OpenAI key."""
-    backend = (os.environ.get("LEMON_BACKEND_URL") or "").strip()
-    gw_token = (os.environ.get("GATEWAY_TOKEN") or "").strip()
-    if backend and gw_token:
-        return f"{backend}/api/lemonade/proxy/v1/images/generations", gw_token
-    api_key = (os.environ.get("OPENAI_API_KEY") or "").strip()
-    if api_key:
-        return "https://api.openai.com/v1/images/generations", api_key
-    return "", ""
-
-
-def request_images(
-    api_key: str,
-    prompt: str,
-    model: str,
-    size: str,
-    quality: str,
-    background: str = "",
-    output_format: str = "",
-    style: str = "",
-    api_url: str = "",
-) -> dict:
-    url = api_url or "https://api.openai.com/v1/images/generations"
-    args = {
-        "model": model,
-        "prompt": prompt,
-        "size": size,
-        "n": 1,
-    }
-
-    # Quality parameter - dall-e-2 doesn't accept this parameter
-    if model != "dall-e-2":
-        args["quality"] = quality
-
-    # Note: response_format no longer supported by OpenAI Images API
-    # dall-e models now return URLs by default
-
-    if model.startswith("gpt-image"):
-        if background:
-            args["background"] = background
-        if output_format:
-            args["output_format"] = output_format
-
-    if model == "dall-e-3" and style:
-        args["style"] = style
-
-    body = json.dumps(args).encode("utf-8")
-    req = urllib.request.Request(
-        url,
-        method="POST",
-        headers={
-            "Authorization": f"Bearer {api_key}",
-            "Content-Type": "application/json",
-        },
-        data=body,
-    )
-    try:
-        with urllib.request.urlopen(req, timeout=300) as resp:
-            return json.loads(resp.read().decode("utf-8"))
-    except urllib.error.HTTPError as e:
-        payload = e.read().decode("utf-8", errors="replace")
-        raise RuntimeError(f"OpenAI Images API failed ({e.code}): {payload}") from e
-
-
-def write_gallery(out_dir: Path, items: list[dict]) -> None:
-    thumbs = "\n".join(
-        [
-            f"""
-<figure>
-  <a href="{it["file"]}"><img src="{it["file"]}" loading="lazy" /></a>
-  <figcaption>{it["prompt"]}</figcaption>
-</figure>
-""".strip()
-            for it in items
-        ]
-    )
-    html = f"""<!doctype html>
-<meta charset="utf-8" />
-<title>openai-image-gen</title>
-<style>
-  :root {{ color-scheme: dark; }}
-  body {{ margin: 24px; font: 14px/1.4 ui-sans-serif, system-ui; background: #0b0f14; color: #e8edf2; }}
-  h1 {{ font-size: 18px; margin: 0 0 16px; }}
-  .grid {{ display: grid; grid-template-columns: repeat(auto-fill, minmax(240px, 1fr)); gap: 16px; }}
-  figure {{ margin: 0; padding: 12px; border: 1px solid #1e2a36; border-radius: 14px; background: #0f1620; }}
-  img {{ width: 100%; height: auto; border-radius: 10px; display: block; }}
-  figcaption {{ margin-top: 10px; color: #b7c2cc; }}
-  code {{ color: #9cd1ff; }}
-</style>
-<h1>openai-image-gen</h1>
-<p>Output: <code>{out_dir.as_posix()}</code></p>
-<div class="grid">
-{thumbs}
-</div>
-"""
-    (out_dir / "index.html").write_text(html, encoding="utf-8")
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser(description="Generate images via OpenAI Images API.")
-    ap.add_argument("--prompt", help="Single prompt. If omitted, random prompts are generated.")
-    ap.add_argument("--count", type=int, default=8, help="How many images to generate.")
-    ap.add_argument("--model", default="gpt-image-1", help="Image model id.")
-    ap.add_argument("--size", default="", help="Image size (e.g. 1024x1024, 1536x1024). Defaults based on model if not specified.")
-    ap.add_argument("--quality", default="", help="Image quality (e.g. high, standard). Defaults based on model if not specified.")
-    ap.add_argument("--background", default="", help="Background transparency (GPT models only): transparent, opaque, or auto.")
-    ap.add_argument("--output-format", default="", help="Output format (GPT models only): png, jpeg, or webp.")
-    ap.add_argument("--style", default="", help="Image style (dall-e-3 only): vivid or natural.")
-    ap.add_argument("--out-dir", default="", help="Output directory (default: ./tmp/openai-image-gen-<ts>).")
-    args = ap.parse_args()
-
-    api_url, api_key = resolve_api_url_and_key()
-    if not api_key:
-        print("No API credentials available for image generation", file=sys.stderr)
-        return 2
-
-    # Apply model-specific defaults if not specified
-    default_size, default_quality = get_model_defaults(args.model)
-    size = args.size or default_size
-    quality = args.quality or default_quality
-
-    count = args.count
-    if args.model == "dall-e-3" and count > 1:
-        print(f"Warning: dall-e-3 only supports generating 1 image at a time. Reducing count from {count} to 1.", file=sys.stderr)
-        count = 1
-
-    out_dir = Path(args.out_dir).expanduser() if args.out_dir else default_out_dir()
-    out_dir.mkdir(parents=True, exist_ok=True)
-
-    prompts = [args.prompt] * count if args.prompt else pick_prompts(count)
-
-    # Determine file extension based on output format
-    if args.model.startswith("gpt-image") and args.output_format:
-        file_ext = args.output_format
-    else:
-        file_ext = "png"
-
-    items: list[dict] = []
-    for idx, prompt in enumerate(prompts, start=1):
-        print(f"[{idx}/{len(prompts)}] {prompt}")
-        res = request_images(
-            api_key,
-            prompt,
-            args.model,
-            size,
-            quality,
-            args.background,
-            args.output_format,
-            args.style,
-            api_url=api_url,
-        )
-        data = res.get("data", [{}])[0]
-        image_b64 = data.get("b64_json")
-        image_url = data.get("url")
-        if not image_b64 and not image_url:
-            raise RuntimeError(f"Unexpected response: {json.dumps(res)[:400]}")
-
-        filename = f"{idx:03d}-{slugify(prompt)[:40]}.{file_ext}"
-        filepath = out_dir / filename
-        if image_b64:
-            filepath.write_bytes(base64.b64decode(image_b64))
-        else:
-            try:
-                urllib.request.urlretrieve(image_url, filepath)
-            except urllib.error.URLError as e:
-                raise RuntimeError(f"Failed to download image from {image_url}: {e}") from e
-
-        items.append({"prompt": prompt, "file": filename})
-
-    (out_dir / "prompts.json").write_text(json.dumps(items, indent=2), encoding="utf-8")
-    write_gallery(out_dir, items)
-    print(f"\nWrote: {(out_dir / 'index.html').as_posix()}")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/skills/ordercli/SKILL.md

@@ -1,47 +0,0 @@
----
-name: ordercli
-description: Foodora-only CLI for checking past orders and active order status (Deliveroo WIP).
-homepage: https://ordercli.sh
-metadata: {"lemonade":{"emoji":"🛵","requires":{"bins":["ordercli"]},"install":[{"id":"brew","kind":"brew","formula":"steipete/tap/ordercli","bins":["ordercli"],"label":"Install ordercli (brew)"},{"id":"go","kind":"go","module":"github.com/steipete/ordercli/cmd/ordercli@latest","bins":["ordercli"],"label":"Install ordercli (go)"}]}}
----
-
-# ordercli
-
-Use `ordercli` to check past orders and track active order status (Foodora only right now).
-
-Quick start (Foodora)
-- `ordercli foodora countries`
-- `ordercli foodora config set --country AT`
-- `ordercli foodora login --email you@example.com --password-stdin`
-- `ordercli foodora orders`
-- `ordercli foodora history --limit 20`
-- `ordercli foodora history show <orderCode>`
-
-Orders
-- Active list (arrival/status): `ordercli foodora orders`
-- Watch: `ordercli foodora orders --watch`
-- Active order detail: `ordercli foodora order <orderCode>`
-- History detail JSON: `ordercli foodora history show <orderCode> --json`
-
-Reorder (adds to cart)
-- Preview: `ordercli foodora reorder <orderCode>`
-- Confirm: `ordercli foodora reorder <orderCode> --confirm`
-- Address: `ordercli foodora reorder <orderCode> --confirm --address-id <id>`
-
-Cloudflare / bot protection
-- Browser login: `ordercli foodora login --email you@example.com --password-stdin --browser`
-- Reuse profile: `--browser-profile "$HOME/Library/Application Support/ordercli/browser-profile"`
-- Import Chrome cookies: `ordercli foodora cookies chrome --profile "Default"`
-
-Session import (no password)
-- `ordercli foodora session chrome --url https://www.foodora.at/ --profile "Default"`
-- `ordercli foodora session refresh --client-id android`
-
-Deliveroo (WIP, not working yet)
-- Requires `DELIVEROO_BEARER_TOKEN` (optional `DELIVEROO_COOKIE`).
-- `ordercli deliveroo config set --market uk`
-- `ordercli deliveroo history`
-
-Notes
-- Use `--config /tmp/ordercli.json` for testing.
-- Confirm before any reorder or cart-changing action.

package/skills/spotify-player/SKILL.md

@@ -1,38 +0,0 @@
----
-name: spotify-player
-description: Terminal Spotify playback/search via spogo (preferred) or spotify_player.
-homepage: https://www.spotify.com
-metadata: {"lemonade":{"emoji":"🎵","requires":{"anyBins":["spogo","spotify_player"]},"install":[{"id":"brew","kind":"brew","formula":"spogo","tap":"steipete/tap","bins":["spogo"],"label":"Install spogo (brew)"},{"id":"brew","kind":"brew","formula":"spotify_player","bins":["spotify_player"],"label":"Install spotify_player (brew)"}]}}
----
-
-# spogo / spotify_player (SECONDARY — prefer AppleScript)
-
-**Default method: AppleScript** (see spotify skill). Use AppleScript to control Spotify unless the user specifically asks for CLI-based control or AppleScript is unavailable.
-
-This CLI skill is an **alternative** for users who prefer terminal-based Spotify control.
-
-**Never use the browser for Spotify.** Do not open open.spotify.com or use browser tools for playback.
-
-Requirements
-- Spotify Premium account.
-- Either `spogo` or `spotify_player` installed.
-
-spogo setup
-- Import cookies: `spogo auth import --browser chrome`
-
-Common CLI commands
-- Search: `spogo search track "query"`
-- Playback: `spogo play|pause|next|prev`
-- Devices: `spogo device list`, `spogo device set "<name|id>"`
-- Status: `spogo status`
-
-spotify_player commands (fallback)
-- Search: `spotify_player search "query"`
-- Playback: `spotify_player playback play|pause|next|previous`
-- Connect device: `spotify_player connect`
-- Like track: `spotify_player like`
-
-Notes
-- Config folder: `~/.config/spotify-player` (e.g., `app.toml`).
-- For Spotify Connect integration, set a user `client_id` in config.
-- TUI shortcuts are available via `?` in the app.

package/skills/youtube-watcher/SKILL.md

@@ -1,51 +0,0 @@
----
-name: youtube-watcher
-description: Fetch and read transcripts from YouTube videos. Use when you need to summarize a video, answer questions about its content, or extract information from it.
-author: michael gathara
-version: 1.0.0
-triggers:
-  - "watch youtube"
-  - "summarize video"
-  - "video transcript"
-  - "youtube summary"
-  - "analyze video"
-metadata: {"lemonade":{"emoji":"📺","requires":{"bins":["yt-dlp"]},"install":[{"id":"brew","kind":"brew","formula":"yt-dlp","bins":["yt-dlp"],"label":"Install yt-dlp (brew)"},{"id":"pip","kind":"pip","package":"yt-dlp","bins":["yt-dlp"],"label":"Install yt-dlp (pip)"}]}}
----
-
-# YouTube Watcher
-
-Fetch transcripts from YouTube videos to enable summarization, QA, and content extraction.
-
-## Usage
-
-### Get Transcript
-
-```bash
-python3 {baseDir}/scripts/get_transcript.py "https://www.youtube.com/watch?v=VIDEO_ID"
-```
-
-## Examples
-
-**Summarize a video:**
-
-1. Get the transcript:
-   ```bash
-   python3 {baseDir}/scripts/get_transcript.py "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
-   ```
-2. Read the output and summarize it for the user.
-
-**Find specific information:**
-
-1. Get the transcript.
-2. Search the text for keywords or answer the user's question based on the content.
-
-## Important
-
-**If `lemon-youtube` is available**, prefer using `lemon-youtube transcript <url>` instead — it uses the authenticated YouTube API and is more reliable. Use this skill as a fallback when the YouTube integration is not connected or `lemon-youtube` is unavailable.
-
-## Notes
-
-- Requires `yt-dlp` to be installed and available in the PATH.
-- Works with videos that have closed captions (CC) or auto-generated subtitles.
-- If a video has no subtitles, the script will fail with an error message.
-- No API key required — uses yt-dlp to fetch publicly available subtitles.

package/skills/youtube-watcher/scripts/get_transcript.py

@@ -1,81 +0,0 @@
-#!/usr/bin/env python3
-import argparse
-import os
-import re
-import subprocess
-import sys
-import tempfile
-from pathlib import Path
-
-def clean_vtt(content: str) -> str:
-    """
-    Clean WebVTT content to plain text.
-    Removes headers, timestamps, and duplicate lines.
-    """
-    lines = content.splitlines()
-    text_lines = []
-    seen = set()
-
-    timestamp_pattern = re.compile(r'\d{2}:\d{2}:\d{2}\.\d{3}\s-->\s\d{2}:\d{2}:\d{2}\.\d{3}')
-
-    for line in lines:
-        line = line.strip()
-        if not line or line == 'WEBVTT' or line.isdigit():
-            continue
-        if timestamp_pattern.match(line):
-            continue
-        if line.startswith('NOTE') or line.startswith('STYLE'):
-            continue
-
-        if text_lines and text_lines[-1] == line:
-            continue
-
-        line = re.sub(r'<[^>]+>', '', line)
-
-        text_lines.append(line)
-
-    return '\n'.join(text_lines)
-
-def get_transcript(url: str):
-    with tempfile.TemporaryDirectory() as temp_dir:
-        cmd = [
-            "yt-dlp",
-            "--write-subs",
-            "--write-auto-subs",
-            "--skip-download",
-            "--sub-lang", "en",
-            "--output", "subs",
-            url
-        ]
-
-        try:
-            subprocess.run(cmd, cwd=temp_dir, check=True, capture_output=True)
-        except subprocess.CalledProcessError as e:
-            print(f"Error running yt-dlp: {e.stderr.decode()}", file=sys.stderr)
-            sys.exit(1)
-        except FileNotFoundError:
-            print("Error: yt-dlp not found. Please install it.", file=sys.stderr)
-            sys.exit(1)
-
-        temp_path = Path(temp_dir)
-        vtt_files = list(temp_path.glob("*.vtt"))
-
-        if not vtt_files:
-            print("No subtitles found.", file=sys.stderr)
-            sys.exit(1)
-
-        vtt_file = vtt_files[0]
-
-        content = vtt_file.read_text(encoding='utf-8')
-        clean_text = clean_vtt(content)
-        print(clean_text)
-
-def main():
-    parser = argparse.ArgumentParser(description="Fetch YouTube transcript.")
-    parser.add_argument("url", help="YouTube video URL")
-    args = parser.parse_args()
-
-    get_transcript(args.url)
-
-if __name__ == "__main__":
-    main()