@jairodri/huckleberry-cli 1.0.2 → 1.1.0

package/skills/x-posting-playwriter/SKILL.md

@@ -0,0 +1,203 @@
+---
+name: x-posting-playwriter
+description: >
+  Post tweets and threads to X/Twitter via Playwriter (browser automation).
+  Use when bird CLI is blocked (error 226) or as primary posting method.
+  Handles Draft.js contenteditable, single tweets and multi-tweet threads
+  with rate limiting. Triggers on: "post to x", "tweet via playwriter",
+  "x thread playwriter", "post tweet browser".
+---
+
+# X Posting via Playwriter
+
+Post tweets and threads to X.com using browser automation via Playwriter. Works when bird CLI is blocked by anti-automation detection (error 226).
+
+**Why this exists:** bird CLI uses cookie auth which X flags as automated. Playwriter controls your actual Chrome browser, which X sees as a real user session.
+
+## Key Discovery: Draft.js + keyboard.insertText
+
+X uses Draft.js for its compose editor. Normal Playwright methods fail:
+- `locator.click()` on textarea → times out (X blocks programmatic clicks on compose)
+- `locator.fill()` → times out
+- `keyboard.type()` → Draft.js doesn't register
+- `keyboard.press()` per char → Draft.js doesn't register
+- `document.execCommand('insertText')` → sometimes works but unreliable
+- `navigator.clipboard.writeText()` + paste → X blocks programmatic paste
+
+**What works:**
+1. `mouse.click()` with coordinates from `boundingBox()` → bypasses X's click interception
+2. `keyboard.insertText()` → triggers Draft.js input handler properly
+3. `mouse.click()` on Post button via coordinates → posts successfully
+
+## Prerequisites
+
+- Chrome must be running with the X account logged in
+- Playwriter extension must be connected
+- Use the correct browser profile (the one logged into X)
+
+```bash
+bunx playwriter@latest session new --browser "profile:108142496489660000816"
+```
+
+## Posting a Single Tweet
+
+```bash
+SESSION=7  # your session id
+
+# Step 1: Navigate to X home
+bunx playwriter@latest -s $SESSION -e "$(cat <<'EOF'
+state.page = context.pages().find(p => p.url() === 'https://x.com/home')
+if (!state.page) {
+  state.page = await context.newPage()
+  await state.page.goto('https://x.com/home', { waitUntil: 'domcontentloaded' })
+}
+await state.page.waitForTimeout(5000)
+console.log("Ready:", state.page.url())
+EOF
+)"
+
+# Step 2: Click textarea via coordinates and type
+bunx playwriter@latest -s $SESSION -e "$(cat <<'EOF'
+const textarea = state.page.locator('[data-testid="tweetTextarea_0"]')
+const tbox = await textarea.boundingBox()
+await state.page.mouse.click(tbox.x + tbox.width/2, tbox.y + tbox.height/2)
+await state.page.waitForTimeout(1000)
+await state.page.keyboard.insertText("YOUR TWEET TEXT HERE")
+await state.page.waitForTimeout(1000)
+const postBtn = state.page.locator('[data-testid="tweetButtonInline"]')
+const pbox = await postBtn.boundingBox()
+await state.page.mouse.click(pbox.x + pbox.width/2, pbox.y + pbox.height/2)
+console.log("Posted!")
+await state.page.waitForTimeout(3000)
+EOF
+)"
+```
+
+## Posting a Thread (Multi-Tweet)
+
+Thread = tweet 1, then reply to tweet 1, then reply to reply, etc.
+
+```bash
+TWEET1_URL=""  # will be captured after first tweet
+
+# Step 1: Post first tweet (same as single tweet above)
+# After posting, capture URL:
+bunx playwriter@latest -s $SESSION -e "$(cat <<'EOF'
+await state.page.goto('https://x.com/AIwithJai', { waitUntil: 'domcontentloaded' })
+await state.page.waitForTimeout(4000)
+const articles = await state.page.locator('article').all()
+const tweet1 = articles[1] // skip pinned
+const timeLink = await tweet1.locator('time').evaluateHandle(el => el.closest('a')?.href)
+state.tweet1Url = await timeLink.evaluate(el => el?.href || el)
+console.log("Tweet 1 URL:", state.tweet1Url)
+EOF
+)"
+
+# Step 2: Wait 45 seconds (rate limiting!)
+sleep 45
+
+# Step 3: Navigate to tweet, click reply, type, post
+bunx playwriter@latest -s $SESSION -e "$(cat <<'EOF'
+await state.page.goto(state.tweet1Url, { waitUntil: 'domcontentloaded' })
+await state.page.waitForTimeout(4000)
+const replyBtn = state.page.locator('[data-testid="reply"]').first()
+const rbox = await replyBtn.boundingBox()
+await state.page.mouse.click(rbox.x + rbox.width/2, rbox.y + rbox.height/2)
+await state.page.waitForTimeout(2000)
+const textarea = state.page.locator('[data-testid="tweetTextarea_0"]').first()
+const tbox = await textarea.boundingBox()
+await state.page.mouse.click(tbox.x + tbox.width/2, tbox.y + tbox.height/2)
+await state.page.waitForTimeout(1000)
+await state.page.keyboard.insertText("REPLY TEXT HERE")
+await state.page.waitForTimeout(1000)
+const postBtn = state.page.locator('[data-testid="tweetButton"]').first()
+const pbox = await postBtn.boundingBox()
+await state.page.mouse.click(pbox.x + pbox.width/2, pbox.y + pbox.height/2)
+console.log("Reply posted!")
+await state.page.waitForTimeout(4000)
+EOF
+)"
+
+# Step 4+: Repeat step 3 for each additional reply
+# ALWAYS wait 45 seconds between each tweet
+# After each reply, reload the page before clicking reply again
+```
+
+## Thread Reply Template (reusable)
+
+For replies 2-N in a thread, after the first reply:
+
+```javascript
+// Reload to see updated thread
+await state.page.reload({ waitUntil: 'domcontentloaded' })
+await state.page.waitForTimeout(3000)
+
+// Click first reply button
+const replyBtns = await state.page.locator('[data-testid="reply"]').all()
+const rbox = await replyBtns[0].boundingBox()
+await state.page.mouse.click(rbox.x + rbox.width/2, rbox.y + rbox.height/2)
+await state.page.waitForTimeout(2000)
+
+// Click textarea and type
+const textarea = state.page.locator('[data-testid="tweetTextarea_0"]').first()
+const tbox = await textarea.boundingBox()
+await state.page.mouse.click(tbox.x + tbox.width/2, tbox.y + tbox.height/2)
+await state.page.waitForTimeout(1000)
+await state.page.keyboard.insertText("TWEET TEXT")
+await state.page.waitForTimeout(1000)
+
+// Click Post
+const postBtn = state.page.locator('[data-testid="tweetButton"]').first()
+const pbox = await postBtn.boundingBox()
+await state.page.mouse.click(pbox.x + pbox.width/2, pbox.y + pbox.height/2)
+console.log("Posted!")
+await state.page.waitForTimeout(4000)
+```
+
+## Element Selectors
+
+| Element | Selector | Notes |
+|---------|----------|-------|
+| Compose textarea | `[data-testid="tweetTextarea_0"]` | Contenteditable div, NOT input |
+| Post button (home) | `[data-testid="tweetButtonInline"]` | Inline compose on home page |
+| Post button (reply) | `[data-testid="tweetButton"]` | Reply compose dialog |
+| Reply button | `[data-testid="reply"]` | On each tweet |
+| Side nav Post button | `[data-testid="SideNav_NewTweet_Button"]` | Left sidebar |
+
+## Rate Limiting (CRITICAL)
+
+- **45 seconds minimum** between each tweet in a thread
+- Use `sleep 45` between playwriter commands
+- Max ~5 tweets per thread per session
+- If Post button stays disabled after insertText, reload the page and retry
+- X may still flag accounts that post too frequently
+
+## Troubleshooting
+
+| Problem | Cause | Fix |
+|---------|-------|-----|
+| Post button stays disabled | Draft.js didn't register text | Reload page, refocus textarea, use `keyboard.insertText()` |
+| Click on textarea times out | X blocks programmatic clicks | Use `mouse.click()` with `boundingBox()` coordinates |
+| Text appears but button disabled | Wrong input method used | Must use `keyboard.insertText()`, not `type()` or `fill()` |
+| Page closed error | User closed the tab | Reset session: `playwriter session reset N` |
+| "Node is not input" error | X uses contenteditable div | Use `textContent()` not `inputValue()` |
+| Reply didn't chain properly | Replied to wrong tweet | Reload page between replies, use first reply button |
+
+## Limitations
+
+- No media upload support yet (images, video)
+- No emoji picker interaction
+- No poll creation
+- No scheduled posts via this method (use typefully for scheduling)
+- Newlines in tweets not supported (keyboard.insertText treats \n as space)
+- For multi-paragraph tweets, use single paragraph with periods for breaks
+
+## When to Use vs Other Methods
+
+| Method | Use When | Reliability |
+|--------|----------|-------------|
+| bird CLI | Normal posting, not flagged | High (when not blocked) |
+| **playwriter** | bird blocked (226), threads | Medium (Draft.js quirks) |
+| typefully | Scheduled posts, reliable API | High (needs API key setup) |
+
+*Last updated: 2026-05-09*

package/skills/x-research/SKILL.md

@@ -0,0 +1,129 @@
+---
+slash_command: false
+name: x-research
+description: Search and research X (Twitter) using bird CLI. Use when researching social media sentiment, trending topics, user activity, or platform-specific content that only exists on X.
+---
+
+## USE WHEN
+**Use this skill when:**
+
+- Researching **X/Twitter-specific content** that won't appear in web search
+- Analyzing **social media sentiment** around topics, brands, or people
+- Tracking **trending hashtags** or conversations on X
+- Researching **user activity** and tweet history (recent tweets, engagement patterns)
+- Finding **real-time reactions** to events or announcements
+- Monitoring **brand mentions** or competitor activity on X
+- Researching **influencer or thought leader** presence and engagement
+- Finding **thread content** or quote tweets (context not in web search)
+
+**Example scenarios:**
+- "What's X saying about NVDA stock today?" → sentiment analysis + recent tweets
+- "Research @elonmusk's recent AI-related tweets" → user tweet history
+- "Find trending hashtags for #AI" → hashtag research
+- "Who's mentioning Nomadixgear on X?" → brand mention monitoring
+- "What's the reaction to this news on X?" → real-time sentiment
+
+## DON'T WHEN
+**Don't use this skill when:**
+
+- Researching **general web content** (use web_search or web_fetch instead)
+- Topic is **not X-specific** (general knowledge, Wikipedia, etc.)
+- Looking for **long-form content** (blog posts, articles) → use web_fetch
+- Researching **official documentation** or press releases → use web_fetch on official sites
+- User wants **broad research across platforms** (not just X)
+- Topic is **evergreen content** (not time-sensitive tweets)
+- Need **in-depth analysis** (X is for quick hits, use deep-research for comprehensive)
+
+**Wrong uses:**
+- "What's the capital of France?" → Use web_search or answer directly
+- "Read this blog post" → Use web_fetch on the URL
+- "Who is CEO of Apple?" → Use web_search, not X search
+- "Find me documentation for X API" → Use web_fetch on docs.x.com
+- "Research competitor features" → Use deep-research or web_search (broader than X)
+
+**Alternative patterns:**
+- Web search → web_search tool (broader sources)
+- URL content → web_fetch tool (direct access)
+- Deep research → deep-research skill (comprehensive with citations)
+- Social media beyond X → Consider platform-specific tools or web_search with site filters
+
+# X Research Skill
+Search and research X (Twitter) using bird CLI.
+
+## Agent-Reach Integration (Free X Search)
+
+**Agent-Reach** (skill: `agent-reach`) provides free X/Twitter search via bird CLI / twitter-cli (no API key, zero config):
+```bash
+agent-reach doctor --json  # Check if X backend is available (shows bird CLI or twitter-cli)
+
+# Search tweets
+twitter search "query" -n 10
+# or
+bird search "query"
+
+# Read single tweet/thread
+twitter tweet URL
+bird tweet URL
+
+# User timeline
+twitter user-posts @username -n 20
+```
+
+**Use Agent-Reach for**: Quick searches, broad discovery, zero-setup research.
+**Use x-research skill for**: Structured queries with time filters, sentiment analysis, historical tracking.
+
+## Usage
+```bash
+
+# Quick search (via x-research skill)
+x-research --query "OpenClaw skills" --time 24h
+
+# Quick search (via Agent-Reach, zero config)
+twitter search "OpenClaw skills" -n 10
+
+# Deep research with analysis (x-research skill)
+x-research --query "what are people saying about NVDA today" --time today --analyze
+
+# Search specific user tweets (x-research skill)
+x-research --query "from:@elonmusk AI" --time 7d
+
+# Read specific tweet/thread (Agent-Reach)
+twitter tweet "https://x.com/user/status/123"
+```
+
+## Time Filters
+- `1h`, `24h`, `today`, `7d`, `30d`
+
+## Output Formats
+
+### Quick Search
+- Tweet text and metadata
+- Author, timestamp, engagement stats
+- URLs and hashtags
+
+### Analysis Mode (--analyze)
+- Sentiment summary (positive/negative/neutral), Top themes extracted, Key accounts mentioned, Engagement patterns
+
+# Recent conversation tracking
+x-research --query "AIwithJai" --time 24h
+
+# Sentiment analysis
+x-research --query "Nomadixgear" --time today --analyze
+
+# Competitor monitoring
+x-research --query "competitor-name" --time 7d
+
+# Trending hashtag research
+x-research --query "#glamping" --time today
+
+## Tips
+- X search is best for **recent, time-sensitive content** (last 1-7 days)
+- For older content, X search is limited — use web_search with site:twitter.com
+- Engagement metrics help identify **influential tweets** vs noise
+- Analysis mode provides **qualitative insights** beyond raw tweet lists
+
+## Limitations
+- X search API limits historical data (usually 7 days for full search, longer for user-specific)
+- Retweets and quote tweets may need manual inspection for context
+- Direct messages (DMs) are not searchable
+- Deleted tweets remain indexed briefly in some cases

package/skills/x-research/x-research.sh

@@ -0,0 +1,85 @@
+#!/bin/bash
+set -e
+
+QUERY=""
+TIME="24h"
+ANALYZE=false
+MAX_RESULTS=20
+
+# Auth tokens from TOOLS.md
+AUTH_TOKEN="16dfd5eaf636980f73c0dfd602df8fea26e63feb"
+CT0="a3b15922b77da31a57fd003b3bc7e769c2617235113ea68327d336244473c5aad91e0519bba46817e37f1c8f4ab87ad8269d82859533da53da252b7fb7d3872f8fe0cb755b0f0507cb1f5ccca936189d"
+
+usage() {
+    echo "Usage: x-research --query <query> [--time 1h|24h|today|7d|30d] [--analyze]"
+    exit 1
+}
+
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --query)
+            QUERY="$2"
+            shift 2
+            ;;
+        --time)
+            TIME="$2"
+            shift 2
+            ;;
+        --analyze)
+            ANALYZE=true
+            shift
+            ;;
+        *)
+            echo "Unknown option: $1"
+            usage
+            ;;
+    esac
+done
+
+if [[ -z "$QUERY" ]]; then
+    echo "Error: --query is required"
+    usage
+fi
+
+echo "🔍 Searching X for: $QUERY"
+echo "⏱️  Time filter: $TIME"
+echo ""
+
+# Run bird search
+bird search "$QUERY" -n $MAX_RESULTS --auth-token "$AUTH_TOKEN" --ct0 "$CT0" 2>&1 | awk '
+BEGIN { topic=1; first=1 }
+/^@[a-zA-Z0-9_]+ \(/ {
+    if (!first) print ""
+    first=0
+    
+    # Parse user and name
+    user=$1
+    name=$0
+    sub(/^@[a-zA-Z0-9_]+ \(/, "", name)
+    sub(/\):.*$/, "", name)
+    
+    # Get the tweet text (everything after the first closing paren and colon)
+    tweet=""
+    for (i=2; i<=NF; i++) {
+        if ($i ~ /\):$/) {
+            tweet_start=i+1
+            break
+        }
+    }
+    for (i=tweet_start; i<=NF; i++) {
+        tweet=tweet " " $i
+    }
+    
+    # Print formatted output
+    print "• " user ":" tweet
+    next
+}
+/^🔗/ {
+    sub(/^🔗 /, "→ ", $0)
+    print $0
+    print ""
+    next
+}
+/^📅/ { next }
+/^[─═]/ { next }
+{ next }'

package/skills/youtube-summarize/SKILL.md

@@ -0,0 +1,90 @@
+---
+slash_command: false
+name: youtube-summarize
+description: Summarize YouTube videos using Google Gemini API with direct URL input. Extract key insights, transcripts, and content ideas from YouTube videos. Use when needing to analyze YouTube content for content creation, research, or information extraction.
+---
+
+# YouTube Summarize Skill
+Summarize YouTube videos using Google's Gemini API with direct YouTube URL input. This skill extracts video content insights without needing transcript downloads.
+
+## How It Works
+The Gemini API accepts YouTube URLs directly in the `fileData.fileUri` field. Gemini fetches and processes the video content, including visual understanding and audio transcription.
+
+## Prerequisites
+- `GEMINI_API_KEY` environment variable set with your Google AI Studio API key
+
+## Usage
+```bash
+
+# Basic summary
+./scripts/youtube-summarize.sh "https://youtu.be/VIDEO_ID"
+
+# Extract content ideas
+./scripts/youtube-summarize.sh "https://www.youtube.com/watch?v=VIDEO_ID" --mode ideas
+
+# Full transcript with timestamps
+./scripts/youtube-summarize.sh "https://youtu.be/VIDEO_ID" --mode transcript
+
+# Custom prompt
+./scripts/youtube-summarize.sh "https://youtu.be/VIDEO_ID" --prompt "What are the key points about X?"
+
+# JSON output
+./scripts/youtube-summarize.sh "https://youtu.be/VIDEO_ID" --json
+```
+
+## Output Modes
+- `summary`: Concise overview (default)
+- `ideas`: Content ideas and angles
+- `transcript`: Full transcript with timestamps
+- `key_points`: Numbered key takeaways
+- `custom`: Use with --prompt for custom analysis
+
+# Extract ideas for your content
+./scripts/youtube-summarize.sh "https://youtu.be/..." --mode ideas --json > ideas.json
+
+# Batch process multiple videos
+for url in urls.txt; do
+ ./scripts/youtube-summarize.sh "$url" --mode key_points
+done
+
+# Get transcript for analysis
+./scripts/youtube-summarize.sh "https://youtu.be/..." --mode transcript > transcript.md
+
+## Limitations
+- Videos must be publicly accessible
+- Some videos (music, restricted) may not work
+- For blocked videos, use direct download + transcription instead
+
+## Agent-Reach Alternative (Free Transcripts)
+
+**Agent-Reach** (skill: `agent-reach`) provides free YouTube transcripts via yt-dlp:
+```bash
+agent-reach doctor --json  # Check if YouTube backend is available
+
+# Download transcripts (no API key needed)
+yt-dlp --write-sub --write-auto-sub --sub-lang "zh-Hans,zh,en" --skip-download -o "/tmp/%(id)s" "URL"
+cat /tmp/VIDEO_ID.*.vtt
+
+# Or use Agent-Reach transcribe for Whisper fallback
+agent-reach configure groq-key YOUR_KEY  # Free at console.groq.com
+agent-reach transcribe "https://www.youtube.com/watch?v=VIDEO_ID"
+```
+
+**Use Agent-Reach for**: Free transcripts without API key, batch processing, when Gemini API fails.
+**Use youtube-summarize for**: Gemini-powered analysis, visual understanding, custom prompts.
+
+## Technical Reference
+API endpoint: `https://generativelanguage.googleapis.com/v1beta/models/gemini-3-flash-preview:generateContent`
+
+Request body includes:
+```json
+{
+ "contents": [{
+ "parts": [
+ {"text": "Summarize this video"},
+ {"fileData": {"fileUri": "https://www.youtube.com/watch?v=..."}}
+ ]
+ }]
+}
+
+See `/scripts/youtube-summarize.sh` for implementation details.

package/skills/youtube-summarize/scripts/youtube-summarize.sh

@@ -0,0 +1,143 @@
+#!/bin/bash
+# youtube-summarize.sh - Summarize YouTube videos using Gemini API
+# Usage: youtube-summarize.sh <youtube_url> [options]
+
+set -e
+
+# Configuration
+API_KEY="${GEMINI_API_KEY:-${GOOGLE_API_KEY:-}}"
+MODEL="gemini-3-flash-preview"
+API_BASE="https://generativelanguage.googleapis.com/v1beta/models"
+
+# Default settings
+MODE="summary"
+JSON_OUTPUT=false
+CUSTOM_PROMPT=""
+
+# Parse arguments
+URL=""
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --mode)
+      MODE="$2"
+      shift 2
+      ;;
+    --prompt)
+      CUSTOM_PROMPT="$2"
+      shift 2
+      ;;
+    --json)
+      JSON_OUTPUT=true
+      shift
+      ;;
+    -*|--*)
+      echo "Unknown option: $1" >&2
+      echo "Usage: $0 <youtube_url> [--mode summary|ideas|transcript|key_points] [--prompt 'custom text'] [--json]" >&2
+      exit 1
+      ;;
+    *)
+      URL="$1"
+      shift
+      ;;
+  esac
+done
+
+# Validate
+if [[ -z "$URL" ]]; then
+  echo "Error: YouTube URL is required" >&2
+  echo "Usage: $0 <youtube_url> [options]" >&2
+  exit 1
+fi
+
+if [[ -z "$API_KEY" ]]; then
+  echo "Error: GEMINI_API_KEY or GOOGLE_API_KEY environment variable is required" >&2
+  exit 1
+fi
+
+# Normalize URL to full YouTube URL
+if [[ "$URL" == "https://youtu.be/"* ]]; then
+  VIDEO_ID="${URL#https://youtu.be/}"
+  FULL_URL="https://www.youtube.com/watch?v=${VIDEO_ID%%\?*}"
+elif [[ "$URL" == "https://www.youtube.com/shorts/"* ]]; then
+  VIDEO_ID="${URL#https://www.youtube.com/shorts/}"
+  FULL_URL="https://www.youtube.com/watch?v=${VIDEO_ID%%\?*}"
+else
+  FULL_URL="$URL"
+fi
+
+# Build prompt based on mode
+case "$MODE" in
+  summary)
+    PROMPT="${CUSTOM_PROMPT:-Provide a concise summary of this YouTube video in 3-5 sentences. Include the main topic, key insights, and any actionable takeaways.}"
+    ;;
+  ideas)
+    PROMPT="${CUSTOM_PROMPT:-Extract 5-10 content ideas from this video that could be turned into blog posts, social media threads, or newsletter content. For each idea, include a title and a brief description.}"
+    ;;
+  transcript)
+    PROMPT="${CUSTOM_PROMPT:-Provide a full transcript of this video with timestamps. Format as: [MM:SS] text}"
+    ;;
+  key_points)
+    PROMPT="${CUSTOM_PROMPT:-Extract the 5-7 most important key points from this video as a numbered list. Each point should be 1-2 sentences.}"
+    ;;
+  custom)
+    PROMPT="${CUSTOM_PROMPT:-Analyze this video}"
+    ;;
+  *)
+    PROMPT="${CUSTOM_PROMPT:-Summarize this video}"
+    ;;
+esac
+
+# Build request JSON
+REQUEST_BODY=$(cat <<EOF
+{
+  "contents": [{
+    "parts": [
+      {"text": "${PROMPT}"},
+      {"fileData": {"fileUri": "${FULL_URL}"}}
+    ]
+  }],
+  "generationConfig": {
+    "maxOutputTokens": 8192,
+    "temperature": 0.4
+  }
+}
+EOF
+)
+
+# Make API call
+URL_ENCODED=$(echo "$FULL_URL" | sed 's/&/\&/g')
+RESPONSE=$(curl -s -X POST "${API_BASE}/${MODEL}:generateContent" \
+  -H "x-goog-api-key: ${API_KEY}" \
+  -H "Content-Type: application/json" \
+  -d "$REQUEST_BODY" 2>&1) || {
+  echo "Error: Failed to connect to Gemini API" >&2
+  exit 1
+}
+
+# Check for API errors
+if echo "$RESPONSE" | grep -q '"error":'; then
+  ERROR=$(echo "$RESPONSE" | grep -o '"message": "[^"]*"' | head -1 | cut -d'"' -f4)
+  echo "API Error: ${ERROR:-$RESPONSE}" >&2
+  exit 1
+fi
+
+# Extract content from response
+SUMMARY=$(echo "$RESPONSE" | sed -n 's/.*"text": "\([^"]*\)".*/\1/p; s/\\n/\n/g' | head -1)
+
+# If extraction failed, try jq or alternative parsing
+if [[ -z "$SUMMARY" ]] && command -v jq >/dev/null 2>&1; then
+  SUMMARY=$(echo "$RESPONSE" | jq -r '.candidates[0].content.parts[0].text' 2>/dev/null)
+fi
+
+# Output
+if [[ "$JSON_OUTPUT" == true ]]; then
+  echo "$RESPONSE"
+else
+  if [[ -n "$SUMMARY" ]]; then
+    printf '%b\n' "$SUMMARY"
+  else
+    # Fallback: output raw response if parsing failed
+    echo "Note: Summary extraction failed, showing raw response:"
+    echo "$RESPONSE"
+  fi
+fi