@plusonelabs/cue 0.0.94 → 0.0.95

package/dist/skills/elevenlabs-tts/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: elevenlabs-tts
+description: ElevenLabs text-to-speech with streaming playback. Use when user asks to speak, say something aloud, or generate voice audio.
+category: media
+type: hybrid
+env:
+  - ELEVENLABS_API_KEY
+metadata:
+  scope: first-party
+  requires:
+    bins: [ffplay]
+---
+
+# ElevenLabs TTS
+
+Lightweight ElevenLabs text-to-speech with streaming audio playback.
+
+## Requirements
+
+- Bun runtime
+- `ffplay` (from ffmpeg) for streaming playback: `brew install ffmpeg`
+- `ELEVENLABS_API_KEY` environment variable
+
+## Usage
+
+Run from the skill's scripts directory:
+
+```bash
+# Stream to speakers (default)
+bun run <skill-dir>/scripts/speak.ts "Hello, world!"
+
+# Choose a voice by name or ID
+bun run <skill-dir>/scripts/speak.ts -v Lily "Hello there"
+bun run <skill-dir>/scripts/speak.ts -v pFZP5JQG7iQjIQuC4Bku "Hello there"
+
+# Save to file instead of playing
+bun run <skill-dir>/scripts/speak.ts -o /tmp/output.mp3 "Hello"
+
+# Save to file AND play
+bun run <skill-dir>/scripts/speak.ts -o /tmp/output.mp3 --play "Hello"
+
+# List available voices
+bun run <skill-dir>/scripts/speak.ts --list
+
+# Adjust speed (0.5-2.0)
+bun run <skill-dir>/scripts/speak.ts --speed 1.2 "Speaking faster"
+
+# Adjust stability and style
+bun run <skill-dir>/scripts/speak.ts --stability 0.7 --style 0.3 "Styled speech"
+
+# Choose model
+bun run <skill-dir>/scripts/speak.ts -m eleven_flash_v2_5 "Fast model"
+```
+
+## Models
+
+| Model                    | Description              |
+| ------------------------ | ------------------------ |
+| `eleven_v3`              | Default, most expressive |
+| `eleven_multilingual_v2` | Stable, multilingual     |
+| `eleven_flash_v2_5`      | Fast, lower latency      |
+| `eleven_turbo_v2_5`      | Balanced speed/quality   |
+
+## Default Voice
+
+Jessica (cgSgspJ2msm6clMCkdW9) — playful, bright, warm. Override with `-v`.
+
+## Voice Aliases
+
+| Alias     | Voice             | Style                                                             |
+| --------- | ----------------- | ----------------------------------------------------------------- |
+| `jessica` | Jessica (default) | Playful, Bright, Warm                                             |
+| `hope`    | Hope              | Clear, Relatable, Charismatic — great for podcasts                |
+| `ryan`    | Ryan              | Casual, Unscripted, Real-Talk — like a friend giving honest takes |
+
+Usage: `-v hope` or `-v jessica`

package/dist/skills/elevenlabs-tts/scripts/speak.ts

@@ -0,0 +1,226 @@
+#!/usr/bin/env bun
+
+import { spawn } from "child_process";
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const API_BASE = "https://api.elevenlabs.io/v1";
+
+function getApiKey(): string {
+  const key = process.env.ELEVENLABS_API_KEY;
+  if (!key) {
+    console.error("Error: ELEVENLABS_API_KEY not set");
+    process.exit(1);
+  }
+  return key;
+}
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const opts: {
+    text: string;
+    voice: string;
+    model: string;
+    output?: string;
+    play: boolean;
+    list: boolean;
+    speed: number;
+    stability?: number;
+    style?: number;
+  } = {
+    text: "",
+    voice: "cgSgspJ2msm6clMCkdW9", // Jessica
+    model: "eleven_v3",
+    play: true,
+    list: false,
+    speed: 1.0,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case "--list":
+      case "-l":
+        opts.list = true;
+        break;
+      case "--voice":
+      case "-v":
+        opts.voice = args[++i];
+        break;
+      case "--model":
+      case "-m":
+        opts.model = args[++i];
+        break;
+      case "--output":
+      case "-o":
+        opts.output = args[++i];
+        opts.play = false;
+        break;
+      case "--speed":
+        opts.speed = parseFloat(args[++i]);
+        break;
+      case "--stability":
+        opts.stability = parseFloat(args[++i]);
+        break;
+      case "--style":
+        opts.style = parseFloat(args[++i]);
+        break;
+      case "--play":
+        opts.play = true;
+        break;
+      default:
+        if (!args[i].startsWith("-")) {
+          opts.text = opts.text ? `${opts.text} ${args[i]}` : args[i];
+        }
+    }
+  }
+  return opts;
+}
+
+async function listVoices(apiKey: string) {
+  const res = await fetch(`${API_BASE}/voices`, {
+    headers: { "xi-api-key": apiKey },
+  });
+  if (!res.ok) {
+    console.error(`Failed to list voices: ${res.status} ${res.statusText}`);
+    process.exit(1);
+  }
+  const data = (await res.json()) as { voices: Array<{ voice_id: string; name: string; category: string; labels?: Record<string, string> }> };
+  console.log(`${"ID".padEnd(24)} ${"NAME".padEnd(40)} CATEGORY`);
+  for (const v of data.voices) {
+    console.log(`${v.voice_id.padEnd(24)} ${v.name.padEnd(40)} ${v.category}`);
+  }
+}
+
+const VOICE_ALIASES: Record<string, string> = {
+  hope: "WAhoMTNdLdMoq1j3wf3I",
+  jessica: "cgSgspJ2msm6clMCkdW9",
+  ryan: "4e32WqNVWRquDa1OcRYZ",
+};
+
+async function resolveVoice(apiKey: string, voice: string): Promise<string> {
+  const alias = VOICE_ALIASES[voice.toLowerCase()];
+  if (alias) {
+    console.error(`Using voice: ${voice} (${alias})`);
+    return alias;
+  }
+  if (/^[a-zA-Z0-9]{20}$/.test(voice)) return voice;
+
+  const res = await fetch(`${API_BASE}/voices`, {
+    headers: { "xi-api-key": apiKey },
+  });
+  if (!res.ok) return voice;
+
+  const data = (await res.json()) as { voices: Array<{ voice_id: string; name: string }> };
+  const match = data.voices.find(
+    (v) => v.name.toLowerCase().startsWith(voice.toLowerCase())
+  );
+  if (match) {
+    console.error(`Using voice: ${match.name} (${match.voice_id})`);
+    return match.voice_id;
+  }
+  return voice;
+}
+
+async function streamToSpeaker(audioStream: ReadableStream<Uint8Array>) {
+  const player = spawn("ffplay", ["-nodisp", "-autoexit", "-loglevel", "quiet", "-i", "pipe:0"], {
+    stdio: ["pipe", "ignore", "ignore"],
+  });
+
+  const reader = audioStream.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      player.stdin.write(value);
+    }
+    player.stdin.end();
+    await new Promise<void>((resolve) => player.on("close", resolve));
+  } catch (e) {
+    player.kill();
+    throw e;
+  }
+}
+
+async function saveToFile(audioStream: ReadableStream<Uint8Array>, path: string) {
+  const reader = audioStream.getReader();
+  const chunks: Uint8Array[] = [];
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  const buffer = Buffer.concat(chunks);
+  const dir = path.substring(0, path.lastIndexOf("/"));
+  if (dir && !existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(path, buffer);
+  console.log(`Saved: ${path} (${buffer.length} bytes)`);
+}
+
+async function speak(opts: ReturnType<typeof parseArgs>, apiKey: string) {
+  if (!opts.text) {
+    console.error("Error: No text provided");
+    process.exit(1);
+  }
+
+  const voiceId = await resolveVoice(apiKey, opts.voice);
+
+  const body: Record<string, unknown> = {
+    text: opts.text,
+    model_id: opts.model,
+  };
+
+  if (opts.speed !== 1.0 || opts.stability !== undefined || opts.style !== undefined) {
+    const settings: Record<string, number> = {};
+    if (opts.speed !== 1.0) settings.speed = opts.speed;
+    if (opts.stability !== undefined) settings.stability = opts.stability;
+    if (opts.style !== undefined) settings.style = opts.style;
+    body.voice_settings = settings;
+  }
+
+  const endpoint = opts.play
+    ? `${API_BASE}/text-to-speech/${voiceId}/stream`
+    : `${API_BASE}/text-to-speech/${voiceId}`;
+
+  const res = await fetch(endpoint, {
+    method: "POST",
+    headers: {
+      "xi-api-key": apiKey,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(body),
+  });
+
+  if (!res.ok) {
+    const err = await res.text();
+    console.error(`TTS failed (${res.status}): ${err}`);
+    process.exit(1);
+  }
+
+  if (!res.body) {
+    console.error("No response body");
+    process.exit(1);
+  }
+
+  if (opts.output) {
+    await saveToFile(res.body as ReadableStream<Uint8Array>, opts.output);
+  } else {
+    await streamToSpeaker(res.body as ReadableStream<Uint8Array>);
+  }
+}
+
+async function main() {
+  const apiKey = getApiKey();
+  const opts = parseArgs();
+
+  if (opts.list) {
+    await listVoices(apiKey);
+  } else {
+    await speak(opts, apiKey);
+  }
+}
+
+main().catch((e) => {
+  console.error(e.message || e);
+  process.exit(1);
+});

package/dist/skills/event/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: event
+description: Create and browse events. Ergonomic wrapper around event posts with structured metadata.
+category: comms
+type: context
+metadata:
+  short-description: Event creation and browsing
+  scope: first-party
+---
+
+Create structured event posts and browse upcoming events. `cue event` is sugar over the post system — it sets `channel: "events"` and builds `metadata.event` automatically.
+
+## Requirements
+
+- `cue` CLI installed and authenticated (`cue` then `/auth`)
+
+## Usage
+
+### Create an event
+
+```bash
+cue event create --title "Event Name" --date "YYYY-MM-DD HH:MM" --location "Place" --link https://...
+```
+
+| Flag         | Required | Description                                            |
+| ------------ | -------- | ------------------------------------------------------ |
+| `--title`    | Yes      | Event name                                             |
+| `--date`     | Yes      | Date and time (e.g., `"2026-02-10 17:30"` or ISO 8601) |
+| `--location` | No       | Venue or address                                       |
+| `--link`     | No       | URL (auto-converts to LinkMediaPart with OG preview)   |
+
+You can also add a description as a positional argument:
+
+```bash
+cue event create --title "AI Night" --date "2026-02-10 17:30" "Monthly meetup for AI builders."
+```
+
+### List events
+
+```bash
+cue event list            # Upcoming events from global feed
+cue event list 50         # With limit
+```
+
+## Examples
+
+```bash
+cue event create --title "AI Tinkerers SF" --date "2026-02-13 18:30" --location "GitHub HQ, SF" --link https://lu.ma/ai-tinkerers-sf
+
+cue event create --title "WorkOS AI Night" --date "2026-02-10 17:30" --location "WorkOS HQ" --link https://lu.ma/workos-ai "AI Night with The Pragmatic Engineer. 246 registered."
+
+cue event list
+```
+
+## What It Builds
+
+`cue event create` generates a post with:
+
+```json
+{
+  "content": [
+    {
+      "type": "post",
+      "title": "AI Night",
+      "description": "...",
+      "media": [{ "type": "link", "url": "..." }]
+    }
+  ],
+  "visibility": "public",
+  "channel": "events",
+  "role": "assistant",
+  "metadata": {
+    "event": {
+      "name": "AI Night",
+      "start_time": "2026-02-10T17:30:00Z",
+      "location": "WorkOS HQ",
+      "url": "..."
+    }
+  }
+}
+```
+
+The backend validates `metadata.event.name` and `metadata.event.start_time` are present for events channel posts.
+
+## Use a specific account
+
+```bash
+cue --profile cue:<account> event create --title "Event" --date "2026-02-10 17:30"
+cue --profile cue:<account> event list
+```
+
+## Troubleshooting
+
+| Error                                             | Fix                                |
+| ------------------------------------------------- | ---------------------------------- |
+| Not authenticated                                 | Run `cue` then `/auth` to log in   |
+| Events require metadata.event.name and start_time | Missing --title or --date          |
+| Invalid date format                               | Use "YYYY-MM-DD HH:MM" or ISO 8601 |

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

@@ -0,0 +1,52 @@
+---
+name: gemini-search
+description: Web search using Gemini API with Google Search grounding. Use when user asks to search the web, look up current information, or needs real-time facts with source citations.
+category: data
+type: hybrid
+env:
+  - GEMINI_API_KEY
+metadata:
+  short-description: Web search with Gemini
+  scope: first-party
+---
+
+Search the web using Gemini's Google Search grounding for AI-synthesized answers with source citations.
+
+## Requirements
+
+- Python 3.10+, `httpx` package
+- `GEMINI_API_KEY` environment variable (or configured via `cue skill env set`)
+- Get your API key at: https://aistudio.google.com/apikey
+
+## Usage
+
+```bash
+# Basic search
+python3 <skill-dir>/generate.py "What happened in tech news today?"
+
+# Get more sources
+python3 <skill-dir>/generate.py "latest Python release" --max-sources 10
+
+# JSON output with full metadata
+python3 <skill-dir>/generate.py "SpaceX launches 2026" --json
+
+# Save results
+python3 <skill-dir>/generate.py "climate summit results" --output results.txt
+
+# Use pro model for deeper analysis
+python3 <skill-dir>/generate.py "compare React vs Vue in 2026" --pro
+```
+
+**Features:**
+
+- AI-synthesized answer grounded in real-time Google Search results
+- Source citations with URLs and titles
+- Supports follow-up context for multi-turn research
+
+## Troubleshooting
+
+| Error                    | Solution                                             |
+| ------------------------ | ---------------------------------------------------- |
+| "GEMINI_API_KEY not set" | Set with: `/skill env set GEMINI_API_KEY <your-key>` |
+| "API error: 400"         | Check query is not empty                             |
+| "API error: 429"         | Rate limited, wait and retry                         |

package/dist/skills/gemini-search/generate.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""
+Gemini Search - Web search using Gemini API with Google Search grounding.
+
+Usage:
+    python generate.py "What's the latest news on AI?"
+    python generate.py "Python 3.14 release date" --json
+    python generate.py "compare frameworks" --pro
+"""
+
+import argparse
+import json
+import os
+import sys
+import time
+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_BASE = "https://generativelanguage.googleapis.com/v1beta/models"
+FLASH_MODEL = "gemini-2.5-flash"
+PRO_MODEL = "gemini-2.5-pro"
+TIMEOUT = 60.0
+
+
+def search(
+    query: str,
+    use_pro: bool = False,
+    context: str | None = None,
+) -> dict:
+    api_key = get_credential("GEMINI_API_KEY", "gemini-search")
+    model = PRO_MODEL if use_pro else FLASH_MODEL
+    url = f"{API_BASE}/{model}:generateContent?key={api_key}"
+
+    contents = []
+    if context:
+        contents.append({"parts": [{"text": context}], "role": "user"})
+        contents.append({"parts": [{"text": "Understood, I have that context."}], "role": "model"})
+    contents.append({"parts": [{"text": query}], "role": "user"})
+
+    payload = {
+        "contents": contents,
+        "tools": [{"google_search": {}}],
+    }
+
+    print(f"Searching with {model}...")
+
+    start_time = time.time()
+
+    with httpx.Client(timeout=TIMEOUT) as client:
+        response = client.post(
+            url,
+            headers={"Content-Type": "application/json"},
+            json=payload,
+        )
+
+        if response.status_code != 200:
+            print(f"Error: API returned {response.status_code}")
+            try:
+                err = response.json()
+                msg = err.get("error", {}).get("message", response.text[:500])
+                print(f"  {msg}")
+            except Exception:
+                print(response.text[:500])
+            sys.exit(1)
+
+        result = response.json()
+
+    processing_time = int((time.time() - start_time) * 1000)
+
+    candidates = result.get("candidates", [])
+    if not candidates:
+        print("Error: No response from model")
+        sys.exit(1)
+
+    candidate = candidates[0]
+    content = candidate.get("content", {})
+    parts = content.get("parts", [])
+    text = "".join(p.get("text", "") for p in parts)
+
+    grounding = candidate.get("groundingMetadata", {})
+    search_queries = grounding.get("webSearchQueries", [])
+    chunks = grounding.get("groundingChunks", [])
+
+    sources = []
+    for chunk in chunks:
+        web = chunk.get("web", {})
+        if web.get("uri"):
+            sources.append({
+                "title": web.get("title", ""),
+                "url": web.get("uri", ""),
+            })
+
+    return {
+        "query": query,
+        "answer": text,
+        "model": model,
+        "search_queries": search_queries,
+        "sources": sources,
+        "source_count": len(sources),
+        "processing_time_ms": processing_time,
+    }
+
+
+def format_results(data: dict) -> str:
+    lines = []
+    lines.append(data["answer"])
+    lines.append("")
+
+    sources = data["sources"]
+    if sources:
+        lines.append("--- Sources ---")
+        seen = set()
+        for i, src in enumerate(sources, 1):
+            url = src["url"]
+            if url in seen:
+                continue
+            seen.add(url)
+            title = src["title"] or "Untitled"
+            lines.append(f"{i}. {title}")
+            lines.append(f"   {url}")
+        lines.append("")
+
+    if data["search_queries"]:
+        lines.append(f"Search queries: {', '.join(data['search_queries'])}")
+
+    return "\n".join(lines)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Web search using Gemini with Google Search grounding",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s "What happened in tech news today?"
+  %(prog)s "latest Python release" --json
+  %(prog)s "compare React vs Vue" --pro
+  %(prog)s "follow up question" --context "previous context here"
+        """,
+    )
+    parser.add_argument("query", help="Search query or question")
+    parser.add_argument(
+        "--pro",
+        action="store_true",
+        help="Use Gemini 2.5 Pro (default: Flash)",
+    )
+    parser.add_argument(
+        "--context", "-c",
+        help="Previous context for follow-up questions",
+    )
+    parser.add_argument(
+        "--output", "-o",
+        help="Output file path (default: print to stdout)",
+    )
+    parser.add_argument(
+        "--json", "-j",
+        action="store_true",
+        help="Output JSON with full metadata",
+    )
+
+    args = parser.parse_args()
+
+    result = search(
+        query=args.query,
+        use_pro=args.pro,
+        context=args.context,
+    )
+
+    if args.json:
+        output_content = json.dumps(result, indent=2, ensure_ascii=False)
+    else:
+        output_content = format_results(result)
+
+    if args.output:
+        output_path = Path(args.output)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        output_path.write_text(output_content, encoding="utf-8")
+        print(f"Saved: {output_path}")
+    else:
+        print(output_content)
+
+    print(f"\n{result['source_count']} sources in {result['processing_time_ms']}ms")
+
+
+if __name__ == "__main__":
+    main()