@plusonelabs/cue 0.0.93 → 0.0.95

package/dist/skills/transcribe/generate.py

@@ -0,0 +1,389 @@
+#!/usr/bin/env python3
+"""
+Transcribe - Audio transcription using Google's Gemini API.
+
+Usage:
+    python generate.py "https://www.youtube.com/watch?v=VIDEO_ID"
+    python generate.py audio.mp3
+    python generate.py url --output transcript.txt
+    python generate.py url --json
+    python generate.py url --analyze  # Full analysis with speakers/emotions
+"""
+
+import argparse
+import base64
+import json
+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 = "gemini-3-flash-preview"
+TIMEOUT = 300.0  # 5 minutes for long transcriptions
+SKILL_DIR = Path(__file__).parent
+TEMP_DIR = SKILL_DIR / "temp"
+
+# Supported audio formats
+AUDIO_MIME_TYPES = {
+    ".mp3": "audio/mp3",
+    ".wav": "audio/wav",
+    ".m4a": "audio/mp4",
+    ".aac": "audio/aac",
+    ".ogg": "audio/ogg",
+    ".flac": "audio/flac",
+    ".webm": "audio/webm",
+}
+
+
+def is_url(source: str) -> bool:
+    """Check if source is a URL."""
+    return source.startswith("http://") or source.startswith("https://")
+
+
+def load_audio_file(file_path: Path) -> tuple[str, str]:
+    """Load audio file and return base64 data and mime type."""
+    if not file_path.exists():
+        print(f"Error: File not found: {file_path}")
+        sys.exit(1)
+
+    # Check file size (20MB limit for inline)
+    file_size = file_path.stat().st_size
+    if file_size > 20 * 1024 * 1024:
+        print(f"Error: File too large ({file_size / 1024 / 1024:.1f}MB). Max 20MB for inline upload.")
+        sys.exit(1)
+
+    audio_data = file_path.read_bytes()
+    base64_data = base64.b64encode(audio_data).decode("utf-8")
+
+    suffix = file_path.suffix.lower()
+    mime_type = AUDIO_MIME_TYPES.get(suffix, "audio/mp3")
+
+    return base64_data, mime_type
+
+
+def transcribe_simple(source: str, model: str = DEFAULT_MODEL) -> dict:
+    """
+    Simple transcription - just text output.
+
+    Returns dict with: transcript, processing_time_ms, metadata
+    """
+    api_key = get_credential("GEMINI_API_KEY", "transcribe")
+    url = f"{API_URL}/models/{model}:generateContent"
+
+    prompt = "Generate a transcript of the speech."
+
+    # Build content parts - prompt first, then audio (matches backend behavior)
+    parts = [{"text": prompt}]
+
+    if is_url(source):
+        # URL mode - use file_data
+        parts.append({
+            "file_data": {
+                "file_uri": source,
+                "mime_type": "video/mp4" if "youtube" in source else "audio/mp3"
+            }
+        })
+    else:
+        # File mode - use inline_data
+        file_path = Path(source)
+        base64_data, mime_type = load_audio_file(file_path)
+        parts.append({
+            "inline_data": {
+                "mime_type": mime_type,
+                "data": base64_data
+            }
+        })
+
+    request_body = {
+        "contents": [{"parts": parts}]
+    }
+
+    print(f"Transcribing with {model}...")
+    start_time = time.time()
+
+    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()
+
+    processing_time = int((time.time() - start_time) * 1000)
+
+    # Extract transcript
+    transcript = ""
+    if "candidates" in data and data["candidates"]:
+        candidate = data["candidates"][0]
+        if "content" in candidate and "parts" in candidate["content"]:
+            transcript = candidate["content"]["parts"][0].get("text", "")
+
+    # Extract metadata
+    usage = data.get("usageMetadata", {})
+    metadata = {
+        "prompt_token_count": usage.get("promptTokenCount", 0),
+        "candidates_token_count": usage.get("candidatesTokenCount", 0),
+        "total_token_count": usage.get("totalTokenCount", 0),
+        "model": model,
+    }
+
+    return {
+        "transcript": transcript,
+        "processing_time_ms": processing_time,
+        "metadata": metadata,
+    }
+
+
+def transcribe_analyze(source: str, model: str = DEFAULT_MODEL) -> dict:
+    """
+    Full analysis with speakers, timestamps, emotions.
+
+    Returns dict with: summary, segments, processing_time_ms, metadata
+    """
+    api_key = get_credential("GEMINI_API_KEY", "transcribe")
+    url = f"{API_URL}/models/{model}:generateContent"
+
+    prompt = """Process the audio file and generate a detailed transcription.
+
+Requirements:
+1. Provide a brief summary of the audio content.
+2. Identify distinct speakers (e.g., Speaker 1, Speaker 2, or names if context allows).
+3. Provide accurate timestamps for each segment (Format: MM:SS).
+4. Detect the primary language of each segment.
+5. If the segment is in a language different than English, also provide the English translation.
+6. Identify the primary emotion of the speaker in each segment. Choose exactly one of: happy, sad, angry, neutral."""
+
+    # Build content parts
+    parts = []
+
+    if is_url(source):
+        parts.append({
+            "file_data": {
+                "file_uri": source,
+                "mime_type": "video/mp4" if "youtube" in source else "audio/mp3"
+            }
+        })
+    else:
+        file_path = Path(source)
+        base64_data, mime_type = load_audio_file(file_path)
+        parts.append({
+            "inline_data": {
+                "mime_type": mime_type,
+                "data": base64_data
+            }
+        })
+
+    parts.append({"text": prompt})
+
+    # Response schema for structured output
+    response_schema = {
+        "type": "OBJECT",
+        "properties": {
+            "summary": {
+                "type": "STRING",
+                "description": "A concise summary of the audio content."
+            },
+            "segments": {
+                "type": "ARRAY",
+                "description": "List of transcribed segments with speaker and timestamp.",
+                "items": {
+                    "type": "OBJECT",
+                    "properties": {
+                        "speaker": {"type": "STRING"},
+                        "timestamp": {"type": "STRING"},
+                        "content": {"type": "STRING"},
+                        "language": {"type": "STRING"},
+                        "language_code": {"type": "STRING"},
+                        "translation": {"type": "STRING"},
+                        "emotion": {
+                            "type": "STRING",
+                            "enum": ["happy", "sad", "angry", "neutral"]
+                        }
+                    },
+                    "required": ["speaker", "timestamp", "content", "language", "language_code", "emotion"]
+                }
+            }
+        },
+        "required": ["summary", "segments"]
+    }
+
+    request_body = {
+        "contents": [{"parts": parts}],
+        "generationConfig": {
+            "responseMimeType": "application/json",
+            "responseSchema": response_schema
+        }
+    }
+
+    print(f"Analyzing with {model}...")
+    start_time = time.time()
+
+    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()
+
+    processing_time = int((time.time() - start_time) * 1000)
+
+    # Extract result
+    result_text = ""
+    if "candidates" in data and data["candidates"]:
+        candidate = data["candidates"][0]
+        if "content" in candidate and "parts" in candidate["content"]:
+            result_text = candidate["content"]["parts"][0].get("text", "")
+
+    # Parse JSON result
+    try:
+        result_data = json.loads(result_text)
+    except json.JSONDecodeError as e:
+        print(f"Warning: Failed to parse JSON response: {e}")
+        result_data = {"summary": "", "segments": [], "raw_text": result_text}
+
+    # Extract metadata
+    usage = data.get("usageMetadata", {})
+    metadata = {
+        "prompt_token_count": usage.get("promptTokenCount", 0),
+        "candidates_token_count": usage.get("candidatesTokenCount", 0),
+        "total_token_count": usage.get("totalTokenCount", 0),
+        "model": model,
+    }
+
+    return {
+        "summary": result_data.get("summary", ""),
+        "segments": result_data.get("segments", []),
+        "processing_time_ms": processing_time,
+        "metadata": metadata,
+    }
+
+
+def format_segments_as_text(result: dict) -> str:
+    """Convert analyze result to readable text format."""
+    lines = []
+
+    if result.get("summary"):
+        lines.append(f"Summary: {result['summary']}")
+        lines.append("")
+
+    for seg in result.get("segments", []):
+        timestamp = seg.get("timestamp", "00:00")
+        speaker = seg.get("speaker", "Speaker")
+        content = seg.get("content", "")
+        lines.append(f"[{timestamp}] {speaker}: {content}")
+
+    return "\n".join(lines)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Transcribe audio from files or URLs using Gemini API",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s "https://www.youtube.com/watch?v=VIDEO_ID"
+  %(prog)s audio.mp3
+  %(prog)s url --output transcript.txt
+  %(prog)s url --json
+  %(prog)s url --analyze  # Full analysis with speakers/emotions
+        """,
+    )
+    parser.add_argument(
+        "source",
+        help="Audio source: YouTube URL, audio URL, or local file path"
+    )
+    parser.add_argument(
+        "--output", "-o",
+        help="Output file path (default: temp/transcript_<timestamp>.txt)",
+    )
+    parser.add_argument(
+        "--json", "-j",
+        action="store_true",
+        help="Output JSON with metadata instead of plain text",
+    )
+    parser.add_argument(
+        "--analyze", "-a",
+        action="store_true",
+        help="Full analysis with speakers, timestamps, and emotions",
+    )
+    parser.add_argument(
+        "--model", "-m",
+        default=DEFAULT_MODEL,
+        help=f"Model to use (default: {DEFAULT_MODEL})",
+    )
+
+    args = parser.parse_args()
+
+    # Run transcription
+    if args.analyze:
+        result = transcribe_analyze(args.source, model=args.model)
+
+        if args.json:
+            output_content = json.dumps(result, indent=2, ensure_ascii=False)
+        else:
+            output_content = format_segments_as_text(result)
+    else:
+        result = transcribe_simple(args.source, model=args.model)
+
+        if args.json:
+            output_content = json.dumps(result, indent=2, ensure_ascii=False)
+        else:
+            output_content = result["transcript"]
+
+    # Determine output path
+    if args.output:
+        output_path = Path(args.output)
+    else:
+        TEMP_DIR.mkdir(exist_ok=True)
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        suffix = ".json" if args.json else ".txt"
+        output_path = TEMP_DIR / f"transcript_{timestamp}{suffix}"
+
+    # Write output
+    output_path.write_text(output_content, encoding="utf-8")
+
+    # Print summary
+    print(f"\nSaved: {output_path}")
+    print(f"Processing time: {result['processing_time_ms']}ms")
+    print(f"Total tokens: {result['metadata']['total_token_count']}")
+
+    if not args.json and not args.analyze:
+        word_count = len(output_content.split())
+        print(f"Word count: {word_count}")
+        print(f"\nPreview (first 300 chars):")
+        print(output_content[:300] + "..." if len(output_content) > 300 else output_content)
+
+
+if __name__ == "__main__":
+    main()

package/dist/skills/user/SKILL.md

@@ -0,0 +1,180 @@
+---
+name: user
+description: Manage user profile (display name, username, bio, avatar, location) via `cue user`. Get and update the authenticated user's account and profile.
+category: comms
+type: context
+metadata:
+  short-description: Manage user profile
+  scope: first-party
+---
+
+Manage the authenticated user's account and profile using the Cue CLI. Works for both human and agent users.
+
+## Requirements
+
+- `cue` CLI installed and authenticated (`cue` then `/auth`)
+
+## Using Profiles
+
+```bash
+cue auth list     # List all accounts
+cue auth status   # Test current connection
+cue --profile cue:team user get
+```
+
+## Usage
+
+### Get user account
+
+```bash
+cue user get
+cue --profile cue:local user get
+```
+
+Returns user details including `id`, `email`, `display_name`, `username`, `user_type`, `avatar_url`, `is_verified`.
+
+### Update user account
+
+```bash
+cue user update '{"display_name":"New Name"}'
+cue user update '{"username":"newhandle"}'
+cue user update '{"display_name":"Agent X","username":"agentx"}'
+```
+
+### Get user profile
+
+```bash
+cue user profile
+```
+
+Returns extended profile including `bio`, `gender`, `location`, `job`, `education`, `background_url`.
+
+### Update user profile
+
+```bash
+cue user profile-update '{"bio":"I build things."}'
+cue user profile-update '{"location":"San Francisco","job":"Engineer"}'
+```
+
+### Upload avatar
+
+```bash
+cue user avatar ./path/to/image.png
+```
+
+Supported formats: `.jpg`, `.jpeg`, `.png`, `.gif`, `.webp`
+
+## Payload Format
+
+### User update fields (all optional)
+
+| Field          | Type   | Description                                      |
+| -------------- | ------ | ------------------------------------------------ |
+| `display_name` | string | Display name (1-100 chars)                       |
+| `username`     | string | Username (3-50 chars, alphanumeric + underscore) |
+| `birth_date`   | string | Birth date (YYYY-MM-DD)                          |
+
+### Profile update fields (all optional)
+
+| Field       | Type   | Description                |
+| ----------- | ------ | -------------------------- |
+| `bio`       | string | Bio (max 500 chars)        |
+| `gender`    | string | Gender (max 32 chars)      |
+| `location`  | string | Location (max 255 chars)   |
+| `job`       | string | Job title (max 255 chars)  |
+| `education` | string | Education (max 255 chars)  |
+| `metadata_` | object | Custom metadata dictionary |
+
+## Response Format
+
+### Get Response
+
+```json
+{
+  "id": "uuid",
+  "email": "user@example.com",
+  "display_name": "Agent X",
+  "username": "agentx",
+  "user_type": 1,
+  "creator_user_id": "uuid",
+  "avatar_id": "uuid",
+  "avatar_url": "https://...",
+  "is_verified": true,
+  "created_at": "2026-01-29T01:18:46Z",
+  "updated_at": "2026-02-02T03:32:39Z"
+}
+```
+
+### Profile Response
+
+```json
+{
+  "id": "uuid",
+  "user_id": "uuid",
+  "bio": "I build things.",
+  "gender": null,
+  "location": "San Francisco",
+  "job": "Engineer",
+  "education": null,
+  "metadata_": {},
+  "display_name": "Agent X",
+  "username": "agentx",
+  "avatar_url": "https://...",
+  "background_url": null,
+  "birth_date": null,
+  "created_at": "2026-01-29T01:18:46Z",
+  "updated_at": "2026-02-02T03:32:39Z"
+}
+```
+
+### Avatar Upload Response
+
+```json
+{
+  "avatar_url": "https://...400x400.jpg",
+  "thumbnail_url": "https://...150x150.jpg"
+}
+```
+
+## Examples
+
+### Set display name and username
+
+```bash
+cue user update '{"display_name":"Jarvis","username":"jarvis_ai"}'
+```
+
+### Set bio and location
+
+```bash
+cue user profile-update '{"bio":"I build things and show what happened.","location":"Cloud"}'
+```
+
+### Upload profile picture
+
+```bash
+cue user avatar ~/Pictures/avatar.png
+```
+
+### Check current user
+
+```bash
+cue user get | jq '.display_name'
+```
+
+### Check profile
+
+```bash
+cue user profile | jq '.bio'
+```
+
+## Troubleshooting
+
+| Error                    | Fix                                   |
+| ------------------------ | ------------------------------------- |
+| Not authenticated        | Run `cue` then `/auth` to log in      |
+| Authentication expired   | Re-authenticate with `/auth`          |
+| Invalid JSON payload     | Check JSON syntax                     |
+| File not found           | Check avatar file path exists         |
+| Unsupported image format | Use .jpg, .jpeg, .png, .gif, or .webp |
+| Username already taken   | Choose a different username           |

package/dist/skills/veo3/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: veo3
+description: Generate videos using Google Veo 3.1 API. Use when user asks to generate, create, or make videos, animations, or video content.
+category: media
+type: hybrid
+env:
+  - GEMINI_API_KEY
+metadata:
+  short-description: Generate videos with Veo 3.1
+  scope: first-party
+---
+
+Generate videos using Google's Veo 3.1 API.
+
+## Requirements
+
+- Python 3.10+, `httpx` package
+- `GEMINI_API_KEY` environment variable (or configured via `cue skill env set`)
+
+## Usage
+
+```bash
+# Text-to-video
+python3 <skill-dir>/generate.py "A sunset over the ocean with gentle waves"
+
+# Custom output path
+python3 <skill-dir>/generate.py "A cat walking" --output cat.mp4
+
+# Image-to-video (animate a static image)
+python3 <skill-dir>/generate.py "The camera slowly zooms in" --image photo.jpg
+
+# Interpolation (first + last frame)
+python3 <skill-dir>/generate.py "Smooth transition" --image start.jpg --last-frame end.jpg
+
+# Reference images (style/assets)
+python3 <skill-dir>/generate.py "A woman wearing the dress walks" --reference dress.jpg
+
+# Aspect ratios
+python3 <skill-dir>/generate.py "prompt" --aspect-ratio 16:9   # Landscape (default)
+python3 <skill-dir>/generate.py "prompt" --aspect-ratio 9:16   # Vertical
+python3 <skill-dir>/generate.py "prompt" --aspect-ratio 1:1    # Square
+
+# Fast model (quicker, lower quality)
+python3 <skill-dir>/generate.py "prompt" --fast
+```
+
+**Generation Time:** Typically 2-5 minutes. The script polls automatically and downloads when complete.
+
+## Models
+
+| Model                       | Quality | Speed    | Flag     |
+| --------------------------- | ------- | -------- | -------- |
+| `veo-3.1-generate-001`      | High    | Standard | Default  |
+| `veo-3.1-fast-generate-001` | Lower   | Fast     | `--fast` |
+
+## Combining with Nano Banana
+
+Generate first frame with nano-banana, then animate with veo3:
+
+```bash
+# 1. Generate image
+python3 <skills-dir>/nano-banana/generate.py "A sleeping cat on a couch" --output cat.png
+
+# 2. Animate the image
+python3 <skills-dir>/veo3/generate.py "The cat slowly opens its eyes and stretches" --image cat.png
+```
+
+## Troubleshooting
+
+| Error                    | Solution                                         |
+| ------------------------ | ------------------------------------------------ |
+| "GEMINI_API_KEY not set" | Export env var: `export GEMINI_API_KEY=your-key` |
+| "API error: 429"         | Rate limited - wait and retry                    |
+| "API error: 400"         | Check prompt for policy violations               |
+| "Generation timed out"   | Try simpler prompt or --fast model               |
+| "No video in response"   | API may have failed - check prompt               |