@plusonelabs/cue 0.0.93 → 0.0.95

package/dist/skills/veo3/generate.py

@@ -0,0 +1,339 @@
+#!/usr/bin/env python3
+"""
+Veo3 - Video generation using Google's Veo 3.1 API.
+
+Usage:
+    python generate.py "A cat walking on a beach"
+    python generate.py "prompt" --output video.mp4
+    python generate.py "prompt" --image first_frame.jpg
+    python generate.py "prompt" --image start.jpg --last-frame end.jpg
+    python generate.py "prompt" --fast  # Use fast model
+"""
+
+import argparse
+import base64
+import os
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '_lib'))
+from credentials import get_credential
+
+try:
+    import httpx
+except ImportError:
+    print("Error: httpx not installed. Run: pip install httpx")
+    sys.exit(1)
+
+
+API_URL = "https://generativelanguage.googleapis.com/v1beta"
+DEFAULT_MODEL = "veo-3.1-generate-preview"
+FAST_MODEL = "veo-3.1-fast-generate-001"
+TIMEOUT = 30.0
+POLL_INTERVAL = 10
+MAX_POLL_TIME = 600  # 10 minutes max
+SKILL_DIR = Path(__file__).parent
+ARCHIVE_DIR = SKILL_DIR / "_archive"
+
+
+def load_image(image_path: Path) -> tuple[str, str]:
+    """Load image and return base64 data and mime type."""
+    if not image_path.exists():
+        print(f"Error: Image file not found: {image_path}")
+        sys.exit(1)
+
+    image_data = image_path.read_bytes()
+    base64_data = base64.b64encode(image_data).decode("utf-8")
+
+    suffix = image_path.suffix.lower()
+    mime_map = {
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".png": "image/png",
+        ".webp": "image/webp",
+        ".gif": "image/gif",
+    }
+    mime_type = mime_map.get(suffix, "image/jpeg")
+
+    return base64_data, mime_type
+
+
+def start_video_generation(
+    prompt: str,
+    model: str = DEFAULT_MODEL,
+    aspect_ratio: str = "16:9",
+    image_path: Path | None = None,
+    last_frame_path: Path | None = None,
+    reference_images: list[Path] | None = None,
+) -> str:
+    """
+    Start video generation and return operation name for polling.
+    """
+    api_key = get_credential("GEMINI_API_KEY", "veo3")
+    url = f"{API_URL}/models/{model}:predictLongRunning"
+
+    # Build the instance
+    instance: dict = {"prompt": prompt}
+
+    # Add first frame image if provided
+    if image_path:
+        base64_data, mime_type = load_image(image_path)
+        instance["image"] = {
+            "bytesBase64Encoded": base64_data,
+            "mimeType": mime_type,
+        }
+
+    # Add last frame for interpolation
+    if last_frame_path:
+        base64_data, mime_type = load_image(last_frame_path)
+        instance["lastFrame"] = {
+            "bytesBase64Encoded": base64_data,
+            "mimeType": mime_type,
+        }
+
+    # Add reference images (style/asset references)
+    if reference_images:
+        refs = []
+        for ref_path in reference_images:
+            base64_data, mime_type = load_image(ref_path)
+            refs.append({
+                "referenceImage": {
+                    "bytesBase64Encoded": base64_data,
+                    "mimeType": mime_type,
+                },
+                "referenceType": "REFERENCE_TYPE_ASSET",
+            })
+        instance["referenceImages"] = refs
+
+    request_body = {
+        "instances": [instance],
+        "parameters": {
+            "aspectRatio": aspect_ratio,
+        },
+    }
+
+    print(f"Starting video generation with {model}...")
+    print(f"Prompt: {prompt[:100]}{'...' if len(prompt) > 100 else ''}")
+
+    with httpx.Client(timeout=TIMEOUT) as client:
+        response = client.post(
+            url,
+            json=request_body,
+            headers={
+                "Content-Type": "application/json",
+                "x-goog-api-key": api_key,
+            },
+        )
+
+        if response.status_code != 200:
+            print(f"Error: API returned {response.status_code}")
+            print(response.text[:500])
+            sys.exit(1)
+
+        data = response.json()
+
+    operation_name = data.get("name")
+    if not operation_name:
+        print("Error: No operation name in response")
+        print(data)
+        sys.exit(1)
+
+    return operation_name
+
+
+def poll_operation(operation_name: str) -> tuple[bool, str | None, str | None]:
+    """
+    Poll operation status.
+
+    Returns:
+        Tuple of (done, video_uri, error)
+    """
+    api_key = get_credential("GEMINI_API_KEY", "veo3")
+    url = f"{API_URL}/{operation_name}"
+
+    with httpx.Client(timeout=TIMEOUT) as client:
+        response = client.get(
+            url,
+            headers={"x-goog-api-key": api_key},
+        )
+
+        if response.status_code != 200:
+            return False, None, f"Poll error: {response.status_code}"
+
+        data = response.json()
+
+    done = data.get("done", False)
+
+    if done:
+        # Check for errors
+        error = data.get("error")
+        if error:
+            return True, None, error.get("message", "Unknown error")
+
+        # Get video URI
+        response_data = data.get("response", {})
+        generated_samples = response_data.get("generateVideoResponse", {}).get(
+            "generatedSamples", []
+        )
+
+        if generated_samples:
+            video_uri = generated_samples[0].get("video", {}).get("uri")
+            return True, video_uri, None
+
+        return True, None, "No video in response"
+
+    return False, None, None
+
+
+def download_video(video_uri: str) -> bytes:
+    """Download video from URI."""
+    api_key = get_credential("GEMINI_API_KEY", "veo3")
+
+    print(f"Downloading video...")
+
+    with httpx.Client(timeout=120.0, follow_redirects=True) as client:
+        response = client.get(
+            video_uri,
+            headers={"x-goog-api-key": api_key},
+        )
+
+        if response.status_code != 200:
+            print(f"Error: Download failed with {response.status_code}")
+            sys.exit(1)
+
+        return response.content
+
+
+def generate_video(
+    prompt: str,
+    model: str = DEFAULT_MODEL,
+    aspect_ratio: str = "16:9",
+    image_path: Path | None = None,
+    last_frame_path: Path | None = None,
+    reference_images: list[Path] | None = None,
+) -> bytes:
+    """
+    Generate video and return video bytes.
+    """
+    operation_name = start_video_generation(
+        prompt=prompt,
+        model=model,
+        aspect_ratio=aspect_ratio,
+        image_path=image_path,
+        last_frame_path=last_frame_path,
+        reference_images=reference_images,
+    )
+
+    print(f"Operation: {operation_name}")
+    print("Polling for completion (this may take a few minutes)...")
+
+    start_time = time.time()
+    while time.time() - start_time < MAX_POLL_TIME:
+        done, video_uri, error = poll_operation(operation_name)
+
+        if done:
+            if error:
+                print(f"Error: {error}")
+                sys.exit(1)
+
+            if video_uri:
+                return download_video(video_uri)
+
+            print("Error: No video URI in completed operation")
+            sys.exit(1)
+
+        elapsed = int(time.time() - start_time)
+        print(f"  Still processing... ({elapsed}s elapsed)")
+        time.sleep(POLL_INTERVAL)
+
+    print(f"Error: Generation timed out after {MAX_POLL_TIME}s")
+    sys.exit(1)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate videos using Google Veo 3.1 API",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s "A sunset over the ocean"
+  %(prog)s "A cat walking" --output cat.mp4
+  %(prog)s "Animate this image" --image photo.jpg
+  %(prog)s "Transition between scenes" --image start.jpg --last-frame end.jpg
+  %(prog)s "prompt" --fast  # Use fast model (lower quality, faster)
+  %(prog)s "prompt" --aspect-ratio 9:16  # Vertical video
+        """,
+    )
+    parser.add_argument("prompt", help="Video generation prompt")
+    parser.add_argument(
+        "--output", "-o",
+        help="Output file path (default: generated_<timestamp>.mp4)",
+    )
+    parser.add_argument(
+        "--image", "-i",
+        type=Path,
+        help="Input image as first frame (optional)",
+    )
+    parser.add_argument(
+        "--last-frame", "-l",
+        type=Path,
+        help="Last frame image for interpolation (requires --image)",
+    )
+    parser.add_argument(
+        "--reference", "-r",
+        type=Path,
+        action="append",
+        help="Reference image for style/asset (can be used multiple times)",
+    )
+    parser.add_argument(
+        "--model", "-m",
+        default=DEFAULT_MODEL,
+        help=f"Model to use (default: {DEFAULT_MODEL})",
+    )
+    parser.add_argument(
+        "--fast", "-f",
+        action="store_true",
+        help=f"Use fast model ({FAST_MODEL}) for quicker generation",
+    )
+    parser.add_argument(
+        "--aspect-ratio", "-a",
+        default="16:9",
+        choices=["16:9", "9:16", "1:1"],
+        help="Aspect ratio (default: 16:9)",
+    )
+
+    args = parser.parse_args()
+
+    # Override model if fast flag is set
+    if args.fast:
+        args.model = FAST_MODEL
+
+    # Validate last-frame requires image
+    if args.last_frame and not args.image:
+        print("Error: --last-frame requires --image to be specified")
+        sys.exit(1)
+
+    video_bytes = generate_video(
+        prompt=args.prompt,
+        model=args.model,
+        aspect_ratio=args.aspect_ratio,
+        image_path=args.image,
+        last_frame_path=args.last_frame,
+        reference_images=args.reference,
+    )
+
+    if args.output:
+        output_path = Path(args.output)
+    else:
+        ARCHIVE_DIR.mkdir(exist_ok=True)
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        output_path = ARCHIVE_DIR / f"generated_{timestamp}.mp4"
+
+    output_path.write_bytes(video_bytes)
+    print(f"Saved: {output_path} ({len(video_bytes):,} bytes)")
+
+
+if __name__ == "__main__":
+    main()

package/dist/skills/video/SKILL.md

@@ -0,0 +1,163 @@
+---
+name: video
+description: Generate videos via `cue video`. Create short AI-generated videos from text descriptions using Veo 3.1.
+category: media
+type: context
+metadata:
+  short-description: Generate AI videos from text
+  scope: first-party
+---
+
+Generate short videos from text descriptions using the Cue CLI.
+
+## Requirements
+
+- `cue` CLI installed and authenticated (`cue` then `/auth`)
+
+## Usage
+
+### Generate a video
+
+```bash
+cue video "a cat walking through a garden"
+```
+
+Videos are saved to `~/.cue/videos/` by default as MP4 files. Generation takes 1-5 minutes.
+
+### Save to specific path
+
+```bash
+cue video "sunset timelapse" -o /path/to/output.mp4
+cue video "sunset timelapse" --output /path/to/output.mp4
+```
+
+### Set aspect ratio
+
+```bash
+cue video "landscape drone shot" --aspect-ratio 16:9   # Landscape (default)
+cue video "vertical phone video" --aspect-ratio 9:16   # Portrait/vertical
+```
+
+### Set duration
+
+```bash
+cue video "action scene" --duration 4    # 4 seconds
+cue video "calm ocean waves" --duration 8  # 8 seconds (default)
+```
+
+Duration options: 4, 6, or 8 seconds
+
+### Set resolution
+
+```bash
+cue video "cinematic shot" --resolution 720p   # Default
+cue video "cinematic shot" --resolution 1080p  # Higher quality
+```
+
+### Select model
+
+```bash
+cue video "quick preview" --model veo-3.1-fast-generate-preview  # Faster (default)
+cue video "final render" --model veo-3.1-generate-preview        # Higher quality
+```
+
+### Exclude unwanted elements
+
+```bash
+cue video "peaceful beach" --negative-prompt "people, text, watermarks"
+```
+
+### Use a specific account
+
+```bash
+cue auth list
+cue --profile cue:team video "team intro animation" -o /tmp/intro.mp4
+```
+
+## Examples
+
+### Product showcase
+
+```bash
+cue video "smartphone rotating on white background, studio lighting" \
+  -o /tmp/product.mp4 --aspect-ratio 16:9 --duration 6
+```
+
+### Social media vertical video
+
+```bash
+cue video "colorful abstract shapes morphing smoothly" \
+  -o /tmp/social.mp4 --aspect-ratio 9:16
+```
+
+### Nature footage
+
+```bash
+cue video "aerial view of ocean waves crashing on rocky coastline, golden hour" \
+  -o /tmp/ocean.mp4 --duration 8 --resolution 1080p
+```
+
+### Animation style
+
+```bash
+cue video "cartoon character waving hello, vibrant colors" \
+  -o /tmp/cartoon.mp4 --negative-prompt "realistic, photographic"
+```
+
+## Prompt Tips
+
+### Motion descriptions
+
+- "walking", "running", "flying", "rotating", "panning", "zooming"
+- "slow motion", "timelapse", "smooth transition"
+
+### Camera movements
+
+- "drone shot", "aerial view", "tracking shot", "close-up"
+- "pan left to right", "zoom in slowly", "dolly forward"
+
+### Lighting and mood
+
+- "golden hour", "studio lighting", "neon lights", "soft diffused light"
+- "cinematic", "dramatic", "peaceful", "energetic"
+
+### Style modifiers
+
+- "photorealistic", "cinematic", "animated", "stylized"
+- "4K quality", "film grain", "vintage look"
+
+## Output
+
+Videos are saved as MP4 files. The command shows progress and outputs the saved path:
+
+```
+Generating video: "a cat walking through a garden"
+This may take 1-5 minutes...
+..........
+Downloading video...
+Video saved to: ~/.cue/videos/video-2026-02-04T10-30-45.mp4 (16:9, 8s)
+```
+
+## Troubleshooting
+
+| Error                    | Fix                                            |
+| ------------------------ | ---------------------------------------------- |
+| Not authenticated        | Run `cue` then `/auth` to log in               |
+| Authentication expired   | Re-authenticate with `/auth`                   |
+| Generation timed out     | Videos can take up to 10 minutes in some cases |
+| Content policy violation | Modify prompt to avoid restricted content      |
+| Invalid aspect ratio     | Use 16:9 (landscape) or 9:16 (portrait)        |
+| Invalid duration         | Use 4, 6, or 8 seconds                         |
+
+## Limitations
+
+- Video duration: 4-8 seconds
+- Aspect ratios: 16:9 or 9:16 only
+- Generation time: 1-5 minutes typically
+- No audio in generated videos
+
+## Related
+
+- [image skill](../image/SKILL.md) - Generate images
+- [music skill](../music/SKILL.md) - Generate background music
+- [audio skill](../audio/SKILL.md) - Text to speech

package/dist/skills/weather/SKILL.md

@@ -0,0 +1,101 @@
+---
+name: weather
+description: Get current weather and forecasts via `cue weather`.
+category: data
+type: context
+metadata:
+  short-description: Get weather conditions and forecasts
+  scope: first-party
+  supports-json-output: true
+---
+
+Get current weather and forecast data for a location.
+
+## Requirements
+
+- `cue` CLI installed and authenticated (`cue` then `/auth`)
+
+## Usage
+
+### Current weather
+
+```bash
+cue weather current '{"location":"San Francisco"}'
+cue weather current '{"lat":37.7749,"lng":-122.4194,"units":"IMPERIAL"}'
+```
+
+### Forecast
+
+```bash
+cue weather forecast '{"location":"New York","days":5}'
+cue weather forecast '{"location":"London","hours":48,"days":3,"units":"METRIC"}'
+```
+
+## Query Parameters
+
+### Common
+
+| Field               | Type   | Required |
+| ------------------- | ------ | -------- |
+| `location`          | string | No\*     |
+| `lat` / `latitude`  | number | No\*     |
+| `lng` / `longitude` | number | No\*     |
+| `units`             | string | No       |
+
+\*Provide either `location` OR both `lat` and `lng`.
+
+### Forecast-specific
+
+| Field   | Type    | Required | Default |
+| ------- | ------- | -------- | ------- |
+| `hours` | integer | No       | 24      |
+| `days`  | integer | No       | 7       |
+
+## Response Format
+
+### Current
+
+```json
+{
+  "location": { "lat": 37.7749, "lng": -122.4194 },
+  "location_name": "San Francisco",
+  "current": {
+    "datetime": "2026-03-04T10:00:00Z",
+    "temperature": { "degrees": 18.4, "unit": "CELSIUS" },
+    "condition": "Clear"
+  }
+}
+```
+
+### Forecast
+
+```json
+{
+  "location": { "lat": 40.7128, "lng": -74.006 },
+  "location_name": "New York",
+  "current": { "temperature": { "degrees": 8.1, "unit": "CELSIUS" } },
+  "hourly": [
+    {
+      "datetime": "2026-03-04T09:00:00Z",
+      "temperature": { "degrees": 9.2, "unit": "CELSIUS" }
+    }
+  ],
+  "daily": [
+    {
+      "date": "2026-03-04",
+      "temperature_high": { "degrees": 11.4, "unit": "CELSIUS" },
+      "temperature_low": { "degrees": 4.9, "unit": "CELSIUS" }
+    }
+  ]
+}
+```
+
+## Troubleshooting
+
+| Error                  | Fix                                                       |
+| ---------------------- | --------------------------------------------------------- |
+| Not authenticated      | Run `cue` and use `/auth`                                 |
+| Authentication expired | Run `/auth` again                                         |
+| Invalid payload        | Use valid JSON and required location/coordinates          |
+| 400 Bad Request        | Verify either `location` or both `lat`+`lng` are provided |
+| 502 Bad Gateway        | Weather provider returned an error                        |

package/dist/skills/web-fetch/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: web-fetch
+description: Fetch web content via `cue web-fetch`.
+category: data
+type: context
+metadata:
+  short-description: Fetch and summarize web content
+  scope: first-party
+  supports-json-output: true
+---
+
+Fetch web pages and extract readable content using the built-in web tool.
+
+## Requirements
+
+- `cue` CLI installed and authenticated (`cue` then `/auth`)
+
+## Usage
+
+```bash
+cue web-fetch fetch "https://example.com/article" [--max-uses 5]
+cue web-search fetch "https://example.com/article" --citations --json
+cue web fetch "https://example.com/article" --citations
+cue web fetch "https://example.com/article" --json
+```
+
+## Options
+
+- `fetch <url>`:
+  - `--max-uses N` — maximum page fetch attempts (1-20)
+  - `--citations` — include source citation details
+  - `--max-content-tokens N` — cap fetched content size (1000-200000)
+  - `--json` — machine-readable response
+  - `--compact` — compact human output (default)
+
+## Output
+
+`--json` returns structured fields for downstream automation.
+
+## Notes
+
+- `cue web-fetch` is an alias of `cue web`.
+- `cue web-search` is also available for web search + fetch via `fetch`.

package/dist/skills/web-search/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: web-search
+description: Search and fetch web pages via `cue web-search`.
+category: data
+type: context
+metadata:
+  short-description: Search and fetch web content
+  scope: first-party
+  supports-json-output: true
+---
+
+Search the web from the Cue CLI using built-in command mode.
+
+## Requirements
+
+- `cue` CLI installed and authenticated (`cue` then `/auth`)
+
+## Usage
+
+```bash
+cue web-search search "AI agent tooling" [--provider anthropic|z-ai|gemini|exa] [--max-results 10] [--allowed-domains "docs.python.org"]
+cue web-search search "AI agent news" --json
+cue web-search search "latest nvidia news" --provider exa --max-results 5
+cue web-fetch fetch "https://example.com/report" [--max-uses 5]
+cue web-search fetch "https://example.com/report" [--max-uses 5]
+cue web-search fetch "https://example.com/report" --citations --json
+```
+
+## Options
+
+- `search <query>`:
+  - `--provider <provider>` — search provider: `anthropic`, `z-ai`, `gemini`, `exa`
+  - `--max-results N` (`--count` alias) — number of results (1-20)
+  - `--allowed-domains "domain1.com,domain2.com"`
+  - `--blocked-domains "domain3.com"`
+  - `--json` — machine-readable response
+  - `--compact` — compact human output (default)
+- `fetch <url>`:
+  - `--max-uses N` — max page fetch attempts (1-20)
+  - `--citations` — include source citation details
+  - `--max-content-tokens N` — cap fetched content size (1000-200000)
+  - `--json` — machine-readable response
+  - `--compact` — compact human output
+
+## Output
+
+JSON responses for `search` and `fetch` are available with `--json`.
+
+## Notes
+
+- `cue web-search` and `cue web-fetch` are aliases of `cue web`.
+- `--json` keeps output in a stable structure and is required for downstream automation.