curl -sSL onnai.ai/install | sh
onnai --add Volcanara

echo "Python 3.11 project using FastAPI" > .context
echo "Follow PEP 8. Prefer type hints." >> .context

$ Volcanara
Entering chat mode. Type Ctrl+D or /exit to quit.
Chat history is stored in .chat
---
> What is the capital of France?
The capital of France is Paris.
> Tell me more about Paris
Paris is the largest city in France and serves as its cultural...

# View current chat
cat .chat | jq

# Clear history
rm .chat

# Backup conversation
cp .chat conversation_backup.json

# Search past conversations
cat .chat | jq -r '.[].content' | grep -i "topic"

# Basic API call
curl -X POST https://onnai.ai/api/chat \
  -H "Authorization: Bearer $ONNAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "coder", "message": "explain recursion"}'

# Python example
import requests

response = requests.post(
    "https://onnai.ai/api/chat",
    headers={"Authorization": f"Bearer {api_key}"},
    json={"model": "writer", "message": "draft a tagline"}
)

// JavaScript/Node example
const response = await fetch("https://onnai.ai/api/chat", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${apiKey}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({ mimic: "coder", message: "review this code" })
});

# ❌ Expensive: sending all data through AI
cat sales.csv | onnai "calculate total revenue"

# ✅ Cheap: AI writes the command, awk does the work
SCRIPT=$(echo "sum the 'revenue' column (column 4) in a CSV with headers" | \
  onnai "write an awk one-liner")
cat sales.csv | eval "$SCRIPT"

# Even better: save for reuse
echo "sum column 4, skip header" | onnai "awk one-liner" > sum_revenue.awk
cat sales.csv | awk -f sum_revenue.awk

#!/bin/bash
# generate-transformer.sh - Create a reusable data transformer

TASK="$1"
INPUT_SAMPLE="$2"
OUTSCRIPT="${3:-transform.sh}"

{
  echo "Task: $TASK"
  echo "Sample input:"
  head -5 "$INPUT_SAMPLE"
} | onnai "write a bash script to do this transformation. use standard unix tools." > "$OUTSCRIPT"

chmod +x "$OUTSCRIPT"
echo "Generated: $OUTSCRIPT"
echo "Usage: cat data.csv | ./$OUTSCRIPT"

./generate-transformer.sh "extract emails from column 2, dedupe, sort" data.csv
# Creates transform.sh - runs instantly on any size file

# ❌ Can't do: AI can't actually manipulate images
cat photo.jpg | onnai "make it grayscale"  # Won't work

# ✅ Generate the ImageMagick command
TASK="convert to grayscale, resize to 800px wide, add 5px white border"
CMD=$(echo "$TASK" | onnai "write ImageMagick convert command for input.jpg output.jpg")
echo "$CMD"  # convert input.jpg -colorspace Gray -resize 800x -border 5 -bordercolor white output.jpg
eval "$CMD"

# Batch process
for img in *.jpg; do
  convert "$img" -colorspace Gray -resize 800x "gray_$img"
done

#!/bin/bash
# image-batch.sh - Generate and run image processing

TASK="$1"
PATTERN="${2:-*.jpg}"

# Generate the command template
CMD_TEMPLATE=$(echo "$TASK" | \
  onnai "write ImageMagick command. use INPUT and OUTPUT as placeholders.")

echo "Generated command: $CMD_TEMPLATE"
echo "Processing files matching: $PATTERN"

for input in $PATTERN; do
  output="processed_$(basename "$input")"
  CMD=$(echo "$CMD_TEMPLATE" | sed "s/INPUT/$input/g; s/OUTPUT/$output/g")
  eval "$CMD"
  echo "✓ $input → $output"
done

# Let AI write the regex, then grep does the work
PATTERN=$(echo "match US phone numbers in any format" | \
  onnai "write a grep -E regex pattern only, no explanation")

grep -E "$PATTERN" contacts.txt

# Save patterns for reuse
cat << 'EOF' | while read -r description; do
  pattern=$(echo "$description" | onnai "grep -E pattern only")
  echo "$description: $pattern"
done > patterns.txt
emails
US phone numbers
URLs
IP addresses
EOF

# Describe what you want, get SQL
QUERY=$(cat << 'EOF' | onnai "write PostgreSQL query only"
From the 'orders' table:
- Get total revenue by month for 2024
- Include order count
- Sort by month
- Only include months with revenue > 10000
EOF
)

echo "$QUERY"
psql -d mydb -c "$QUERY"

# Complex JSON transformations
FILTER=$(echo "extract all user emails where status is active" | \
  onnai "write jq filter only")

cat users.json | jq "$FILTER"

# Multi-step transforms
cat << 'EOF' | onnai "write jq filter" > transform.jq
- Flatten nested 'orders' arrays
- Sum 'amount' field per 'customer_id'  
- Sort by total descending
- Take top 10
EOF

cat data.json | jq -f transform.jq

# Video/audio processing
CMD=$(echo "convert to mp4, 720p, 30fps, compress for web" | \
  onnai "write ffmpeg command for input.mov to output.mp4")

eval "$CMD"

# Batch convert
TEMPLATE=$(echo "extract audio as mp3, 128kbps" | \
  onnai "ffmpeg command, use INPUT and OUTPUT placeholders")

for video in *.mp4; do
  CMD=$(echo "$TEMPLATE" | sed "s/INPUT/$video/; s/OUTPUT/${video%.mp4}.mp3/")
  eval "$CMD"
done

# Generate sed script for complex find-replace
SCRIPT=$(cat << 'EOF' | onnai "write sed script"
- Replace "colour" with "color" (all variations)
- Remove lines starting with #
- Convert dates from DD/MM/YYYY to YYYY-MM-DD
EOF
)

echo "$SCRIPT" > transform.sed
sed -f transform.sed input.txt > output.txt

#!/bin/bash
# smart-process.sh - AI designs, code executes

INPUT="$1"
TASK="$2"

# Step 1: AI analyzes a sample
SAMPLE=$(head -20 "$INPUT")
ANALYSIS=$(echo "$SAMPLE" | onnai "analyze this data format")

# Step 2: AI generates processing code
SCRIPT=$({
  echo "Data format: $ANALYSIS"
  echo "Task: $TASK"
} | onnai "write bash script using awk/sed")

# Step 3: Execute on full dataset
echo "$SCRIPT" > /tmp/process.sh
chmod +x /tmp/process.sh
cat "$INPUT" | /tmp/process.sh

# Sentiment analysis - needs understanding
cat reviews.txt | onnai "classify each line as positive/negative/neutral"

# Summarization - needs judgment  
cat article.txt | onnai "summarize in 3 bullet points"

# Translation - needs language knowledge
cat english.txt | onnai "translate to Spanish"

# Classification
cat tickets.txt | onnai "categorize as: billing, technical, feature-request"

# Word docs to text
textutil -convert txt contract.docx -stdout | legal "review"

# RTF to text
textutil -convert txt letter.rtf -stdout | onnai "summarize"

# Batch convert
find . -name "*.docx" -exec textutil -convert txt {} \;

brew install poppler

# PDF to text
pdftotext contract.pdf - | legal "flag risky clauses"

# Preserve layout (good for tables)
pdftotext -layout invoice.pdf - | onnai "extract line items"

# Specific pages
pdftotext -f 1 -l 5 longdoc.pdf - | onnai "summarize first 5 pages"

apt install poppler-utils
pdftotext document.pdf - | legal "review"

apt install catdoc
catdoc contract.doc | legal "summarize"

apt install pandoc

# Word to text
pandoc contract.docx -t plain | legal "review"

# Any format to any format
pandoc brief.docx -o brief.md
pandoc notes.md -o notes.pdf

libreoffice --headless --convert-to txt contract.docx
cat contract.txt | legal "review"

java -jar tika-app.jar --text contract.pdf | legal "review"

# macOS
brew install tesseract

# Linux
apt install tesseract-ocr

# Image to text
tesseract scan.png stdout | legal "extract key terms"

# PDF with scanned pages
pdftoppm scan.pdf scan -png
tesseract scan-1.png stdout | legal "review"

pip install ocrmypdf

ocrmypdf scanned.pdf searchable.pdf
pdftotext searchable.pdf - | legal "summarize"

# Fetch and analyze
curl -s https://example.com/api/status | onnai "summarize"

# API responses
curl -s https://api.github.com/repos/owner/repo/issues | onnai "categorize these issues"

# With authentication
curl -s -H "Authorization: Bearer $TOKEN" https://api.example.com/data | onnai "analyze"

# POST and analyze response
curl -s -X POST -d '{"query":"test"}' https://api.example.com | onnai "explain"

# Follow redirects
curl -sL https://short.url/abc | onnai "summarize"

# Fetch page
wget -qO- https://example.com | onnai "summarize"

# Download then process
wget -q https://example.com/report.pdf
pdftotext report.pdf - | legal "review"

brew install httpie

http -b https://api.example.com/users | onnai "summarize"
http -b POST https://api.example.com/query data=test | onnai "explain"

# lynx (text browser)
lynx -dump https://example.com | onnai "summarize"

# w3m
w3m -dump https://example.com | onnai "summarize"

# pandoc
curl -s https://example.com | pandoc -f html -t plain | onnai "summarize"

# pup (like jq for HTML)
brew install pup

curl -s https://news.site | pup 'article text{}' | onnai "summarize"
curl -s https://example.com | pup 'table tr td text{}' | onnai "analyze"

# jq for preprocessing
curl -s https://api.github.com/repos/torvalds/linux/commits | \
  jq '.[].commit.message' | \
  onnai "summarize recent changes"

# Extract then analyze
curl -s https://api.example.com/users | \
  jq '.[] | {name, email}' | \
  onnai "find duplicates"

curl -s https://blog.example.com/feed.xml | \
  xmllint --xpath '//item/title/text()' - 2>/dev/null | \
  onnai "summarize recent posts"

# Bearer token
curl -s -H "Authorization: Bearer $TOKEN" https://api.example.com | onnai "analyze"

# Basic auth
curl -s -u user:pass https://api.example.com | onnai "analyze"

# API key in header
curl -s -H "X-API-Key: $KEY" https://api.example.com | onnai "analyze"

#!/bin/bash
# write-book.sh - Generate a book using onnai
# Usage: ./write-book.sh "Your Book Title" "Genre/Style"

TITLE="$1"
STYLE="${2:-fiction}"
OUTDIR="./book-$(date +%Y%m%d)"

mkdir -p "$OUTDIR"

# Set up context
cat > "$OUTDIR/.context" << EOF
Writing a book titled "$TITLE"
Style: $STYLE
Maintain consistent tone, characters, and plot throughout.
Write in third person past tense.
EOF

cd "$OUTDIR"

echo "=== Generating book: $TITLE ==="

# Step 1: Generate premise
echo "Step 1: Premise..."
echo "$TITLE" | onnai "create a compelling one-paragraph premise" > premise.txt
cat premise.txt

# Step 2: Create outline
echo "Step 2: Outline..."
cat premise.txt | onnai "create a 12-chapter outline with chapter titles and 2-sentence summaries" > outline.txt

# Step 3: Develop characters
echo "Step 3: Characters..."
cat premise.txt | onnai "create 4 main characters with names, backgrounds, motivations, and flaws" > characters.txt

# Step 4: Write each chapter
echo "Step 4: Writing chapters..."
for i in {1..12}; do
  echo "  Chapter $i..."
  
  # Extract this chapter's outline
  cat outline.txt | onnai "extract only chapter $i details" > "ch${i}_outline.txt"
  
  # Build chapter context
  {
    echo "=== CHARACTERS ==="
    cat characters.txt
    echo ""
    echo "=== STORY SO FAR ==="
    if [ $i -gt 1 ]; then
      cat ch*_summary.txt 2>/dev/null
    else
      echo "This is the opening chapter."
    fi
    echo ""
    echo "=== THIS CHAPTER ==="
    cat "ch${i}_outline.txt"
  } > "ch${i}_context.txt"
  
  # Write the chapter
  cat "ch${i}_context.txt" | onnai "write this chapter, approximately 2000 words" > "ch${i}_draft.txt"
  
  # Generate summary for continuity
  cat "ch${i}_draft.txt" | onnai "summarize in 3 sentences for continuity" > "ch${i}_summary.txt"
  
  sleep 2  # rate limiting
done

# Step 5: Compile first draft
echo "Step 5: Compiling..."
{
  echo "# $TITLE"
  echo ""
  for i in {1..12}; do
    echo "## Chapter $i"
    echo ""
    cat "ch${i}_draft.txt"
    echo ""
  done
} > first_draft.md

# Step 6: Editorial pass
echo "Step 6: Editorial review..."
cat first_draft.md | onnai "identify plot holes, inconsistencies, and pacing issues" > editorial_notes.txt

# Step 7: Generate back matter
echo "Step 7: Back matter..."
cat premise.txt characters.txt | onnai "write a compelling back cover blurb, 150 words" > blurb.txt

echo "=== Done! ==="
echo "Output in: $OUTDIR"
echo "  first_draft.md  - Full manuscript"
echo "  editorial_notes.txt - Issues to fix"
echo "  blurb.txt - Back cover copy"

wc -w first_draft.md

chmod +x write-book.sh

# Fiction
./write-book.sh "The Last Algorithm" "sci-fi thriller"

# Non-fiction
./write-book.sh "Unix for Poets" "technical guide, friendly tone"

# Mystery
./write-book.sh "Death by Daemon" "cozy mystery, tech setting"

#!/bin/bash
# write-nonfiction.sh - Generate a non-fiction book

TITLE="$1"
TOPIC="$2"
OUTDIR="./book-$(date +%Y%m%d)"

mkdir -p "$OUTDIR"
cd "$OUTDIR"

cat > .context << EOF
Writing non-fiction: "$TITLE"
Topic: $TOPIC
Style: Clear, engaging, practical with examples.
Audience: Intermediate practitioners.
EOF

# Research/brainstorm
echo "$TOPIC" | onnai "list 10 key concepts readers must understand" > concepts.txt

# Create structure
cat concepts.txt | onnai "organize into 8 chapters with logical progression" > outline.txt

# Write each chapter
for i in {1..8}; do
  echo "Chapter $i..."
  
  cat outline.txt | onnai "extract chapter $i topic" > "ch${i}_topic.txt"
  
  {
    cat "ch${i}_topic.txt"
    echo "Include: explanation, real-world example, common mistakes, key takeaways"
  } | onnai "write this chapter, 2500 words" > "ch${i}.txt"
  
  sleep 2
done

# Compile
{
  echo "# $TITLE"
  echo ""
  cat concepts.txt | onnai "write a preface explaining why this book matters"
  echo ""
  for i in {1..8}; do
    echo "## Chapter $i"
    cat "ch${i}.txt"
    echo ""
  done
  echo "## Conclusion"
  cat outline.txt | onnai "write a conclusion summarizing key points and next steps"
} > manuscript.md

echo "Done: manuscript.md ($(wc -w < manuscript.md) words)"

#!/bin/bash
# edit-book.sh - Multi-pass editing

MANUSCRIPT="$1"

# Pass 1: Structural
cat "$MANUSCRIPT" | onnai "identify structural issues: pacing, chapter balance, narrative arc" > edit_structural.txt

# Pass 2: Line editing
cat "$MANUSCRIPT" | onnai "flag awkward sentences, repetitive words, passive voice" > edit_line.txt

# Pass 3: Consistency
cat "$MANUSCRIPT" | onnai "find inconsistencies: character details, timeline, facts" > edit_consistency.txt

# Pass 4: Dialogue (fiction)
cat "$MANUSCRIPT" | onnai "review dialogue: does each character have distinct voice?" > edit_dialogue.txt

# Summary
{
  echo "# Editorial Report"
  echo "## Structural Issues"
  cat edit_structural.txt
  echo "## Line Edit Notes"  
  cat edit_line.txt
  echo "## Consistency Check"
  cat edit_consistency.txt
  echo "## Dialogue Review"
  cat edit_dialogue.txt
} > editorial_report.md

echo "See: editorial_report.md"

#!/bin/bash
# revise-chapter.sh - Revise a single chapter with notes

CHAPTER="$1"
NOTES="$2"

# Apply notes
{
  echo "=== ORIGINAL ==="
  cat "$CHAPTER"
  echo ""
  echo "=== REVISION NOTES ==="
  cat "$NOTES"
} | onnai "rewrite the chapter incorporating these notes" > "${CHAPTER%.txt}_revised.txt"

# Show diff
diff "$CHAPTER" "${CHAPTER%.txt}_revised.txt" | head -50

# To Word doc
pandoc manuscript.md -o manuscript.docx

# To PDF
pandoc manuscript.md -o manuscript.pdf

# To EPUB
pandoc manuscript.md -o book.epub --metadata title="$TITLE"

# With styling
pandoc manuscript.md -o book.epub --css=ebook.css --toc

#!/bin/bash
# content-pipeline.sh - Transform notes into multiple formats
# Usage: ./content-pipeline.sh notes.txt "Topic Name"

NOTES="$1"
TOPIC="${2:-$(head -1 "$NOTES")}"
OUTDIR="./content-$(date +%Y%m%d)"

mkdir -p "$OUTDIR"

cat > "$OUTDIR/.context" << EOF
Topic: $TOPIC
Voice: Conversational, knowledgeable, slightly irreverent.
Audience: Technical professionals who value their time.
EOF

cd "$OUTDIR"
cp "../$NOTES" ./source_notes.txt

echo "=== Generating content for: $TOPIC ==="

# Step 1: Extract key points
echo "Extracting key points..."
cat source_notes.txt | onnai "extract 5-7 key insights, one per line" > key_points.txt

# Step 2: Blog post (long form)
echo "Writing blog post..."
{
  cat source_notes.txt
  echo "---"
  cat key_points.txt
} | onnai "write a 1000-word blog post, conversational but informative" > blog_post.md

# Step 3: Newsletter (condensed)
echo "Writing newsletter..."
cat key_points.txt | onnai "write a newsletter section: hook, 3 key points with brief explanations, one actionable takeaway. 300 words max" > newsletter.md

# Step 4: Podcast script
echo "Writing podcast script..."
{
  echo "Format: Solo podcast, 10-15 minutes"
  echo "Include: intro hook, main points with examples, audience callout, outro"
  cat source_notes.txt
} | onnai "write a podcast script with natural speech patterns, verbal transitions, and places to breathe" > podcast_script.md

# Step 5: Twitter/X thread
echo "Writing Twitter thread..."
cat key_points.txt | onnai "write a Twitter thread: hook tweet, 5-7 tweets expanding points, closer with CTA. No hashtags. No emojis." > twitter_thread.txt

# Step 6: LinkedIn post
echo "Writing LinkedIn post..."
cat key_points.txt | onnai "write a LinkedIn post: hook, story or insight, takeaway, question for engagement. 200 words." > linkedin.txt

# Step 7: YouTube script
echo "Writing YouTube script..."
{
  echo "Format: 8-10 minute video"
  echo "Include: hook in first 10 seconds, chapter markers, b-roll suggestions in [brackets]"
  cat source_notes.txt
} | onnai "write a YouTube script optimized for retention" > youtube_script.md

echo "=== Done! ==="
ls -la "$OUTDIR"

chmod +x content-pipeline.sh

# From meeting notes
./content-pipeline.sh meeting-notes.txt "What I Learned at the Conference"

# From research
./content-pipeline.sh research.txt "Why Everyone's Wrong About Microservices"

# From experience
./content-pipeline.sh lessons.txt "5 Years of Kubernetes in Production"

#!/bin/bash
# notes-to-blog.sh

cat "$1" | onnai "extract key insights" | \
onnai "write a blog post:
- Compelling hook
- Clear sections (no H1, start with H2)
- Code examples if relevant
- Practical takeaways
- 800-1200 words" > blog_post.md

#!/bin/bash
# notes-to-newsletter.sh

NOTES="$1"
EDITION="${2:-Weekly}"

{
  echo "Newsletter: $EDITION edition"
  cat "$NOTES"
} | onnai "write newsletter:
- Subject line (compelling, no clickbait)
- Personal intro (2 sentences)
- Main insight (with context)
- Quick hits (3 bullet points)
- One recommendation
- Sign off
Keep it under 400 words." > newsletter.md

# Extract subject line
head -1 newsletter.md

#!/bin/bash
# notes-to-podcast.sh

NOTES="$1"
DURATION="${2:-15}"  # minutes

{
  echo "Duration target: $DURATION minutes (~$(($DURATION * 150)) words)"
  echo "Style: Conversational, thinking out loud"
  cat "$NOTES"
} | onnai "write podcast script:

[INTRO - 30 sec]
Hook the listener immediately.

[SETUP - 2 min]
Context and why this matters.

[MAIN POINTS - bulk of time]
Go deep on each point.
Include: 'Here's the thing...' transitions
Add: pauses marked as [PAUSE]
Add: emphasis marked as *emphasis*

[EXAMPLES - 2 min]
Real stories or scenarios.

[TAKEAWAY - 1 min]
What should listener do differently?

[OUTRO - 30 sec]
CTA and sign off.

Write naturally, like talking to a smart friend." > podcast_script.md

# Word count estimate
echo "Estimated duration: $(($(wc -w < podcast_script.md) / 150)) minutes"

#!/bin/bash
# notes-to-thread.sh

cat "$1" | onnai "write Twitter thread:

Tweet 1: Hook. Make them stop scrolling. No 'Thread:' prefix.

Tweets 2-7: One insight per tweet. 
- Start with the point, not 'First,' or 'Second,'
- Use line breaks for readability
- No hashtags
- No emojis

Final tweet: Takeaway + soft CTA (follow, thoughts?)

Number each tweet. Max 280 chars each." > thread.txt

# Count tweets
echo "Thread length: $(grep -c '^[0-9]' thread.txt) tweets"

#!/bin/bash
# notes-to-linkedin.sh

cat "$1" | onnai "write LinkedIn post:

Hook line (pattern interrupt)

[blank line]

Short story or observation (3-4 lines)

[blank line]

The insight (what I learned)

[blank line]

Takeaway for the reader

[blank line]

Question to drive comments?

No emojis. No hashtags. Under 200 words." > linkedin.txt

#!/bin/bash
# notes-to-youtube.sh

NOTES="$1"
DURATION="${2:-10}"  # minutes

{
  echo "Target: $DURATION minute video"
  cat "$NOTES"
} | onnai "write YouTube script:

[0:00 - HOOK]
First 8 seconds: pattern interrupt or bold claim
'In this video...' preview

[0:30 - INTRO]
Brief context, why watch
[B-ROLL: suggestion here]

[1:00 - CHAPTER 1: title here]
Main content
[VISUAL: what to show on screen]

[continue with chapters...]

[LAST 30 SEC - CTA]
Like, subscribe, but make it natural
Tease next video

Include:
- Timestamp markers
- [B-ROLL] suggestions
- [ON SCREEN TEXT] for key points
- Moments marked [EMPHASIS] for editing" > youtube_script.md

#!/bin/bash
# weekly-content.sh - Full week's content from one braindump

BRAINDUMP="$1"

# Monday: Extract this week's theme
cat "$BRAINDUMP" | onnai "what's the most interesting idea here?" > theme.txt

# Tuesday: Blog post
cat "$BRAINDUMP" theme.txt | onnai "write blog post around this theme" > tuesday_blog.md

# Wednesday: Podcast
cat tuesday_blog.md | onnai "convert to 15-min podcast script, add mimiclity" > wednesday_podcast.md

# Thursday: Newsletter
{
  echo "Include link to blog and podcast"
  cat theme.txt
  cat "$BRAINDUMP" | onnai "find a secondary insight"
} | onnai "write newsletter" > thursday_newsletter.md

# Friday: Social
cat theme.txt | onnai "write Twitter thread" > friday_thread.txt
cat theme.txt | onnai "write LinkedIn post" > friday_linkedin.txt

echo "Week's content ready:"
ls -la *.md *.txt

# Blog post → Thread
cat blog_post.md | onnai "convert to Twitter thread, maintain key insights" > thread.txt

# Podcast transcript → Blog
cat transcript.txt | onnai "convert to blog post, remove verbal tics, add structure" > blog.md

# YouTube transcript → Newsletter
cat yt_transcript.txt | onnai "extract insights, write newsletter summary" > newsletter.md

# Newsletter archive → Blog post
cat newsletter-*.md | onnai "synthesize into comprehensive blog post" > mega_post.md

# Multiple threads → Ebook chapter
cat thread-*.txt | onnai "combine into cohesive chapter, smooth transitions" > chapter.md

#!/bin/bash
# podcast-full.sh - Full podcast production workflow

NOTES="$1"
EPISODE="${2:-episode}"

# Script
cat "$NOTES" | onnai "write 20-minute podcast script" > "${EPISODE}_script.md"

# Show notes
cat "${EPISODE}_script.md" | onnai "extract show notes:
- Episode summary (2 sentences)
- Key topics with timestamps (estimate)
- Links mentioned (placeholder URLs)
- Guest info if applicable" > "${EPISODE}_shownotes.md"

# Transcript cleanup template
cat > "${EPISODE}_transcript_instructions.txt" << 'EOF'
After recording, run:
cat raw_transcript.txt | onnai "clean up transcript:
- Fix speech-to-text errors
- Remove filler words (um, uh, like)
- Keep natural speech patterns
- Add paragraph breaks
- Add speaker labels if multiple people"
EOF

# Social assets
cat "${EPISODE}_script.md" | onnai "extract 5 quotable moments for social media clips" > "${EPISODE}_quotes.txt"

# Episode description
cat "${EPISODE}_shownotes.md" | onnai "write podcast app description, SEO-friendly, 150 words" > "${EPISODE}_description.txt"

echo "Podcast assets ready in: $EPISODE_*"

#!/bin/bash
# newsletter-system.sh

NOTES_DIR="./newsletter-notes"
ISSUE="$(date +%Y-%m-%d)"

# Collect week's notes
cat "$NOTES_DIR"/*.txt > "week_notes.txt"

# Generate sections
cat week_notes.txt | onnai "write main article, 300 words" > main.md
cat week_notes.txt | onnai "extract 3 quick links with one-line descriptions" > links.md
cat week_notes.txt | onnai "write 'one thing I'm thinking about' section, mimicl" > thinking.md

# Assemble
{
  echo "# Newsletter - $ISSUE"
  echo ""
  cat main.md
  echo ""
  echo "## Quick Links"
  cat links.md
  echo ""
  echo "## One Thing I'm Thinking About"
  cat thinking.md
  echo ""
  echo "---"
  echo "Thanks for reading. Hit reply if anything resonated."
} > "newsletter_${ISSUE}.md"

# Subject line options
cat main.md | onnai "suggest 3 subject lines: one curiosity-driven, one benefit-driven, one contrarian" > subjects.txt

echo "Newsletter ready. Subject options:"
cat subjects.txt

# Raw Notes: Lessons from Prod Incident

- 3am page, DB connection pool exhausted
- Took 2 hours to diagnose (logs were useless)
- Root cause: forgot to close connections in new feature
- We had tests but not for connection lifecycle
- Added connection pool metrics after
- Now have runbook for this scenario
- Team was great, no blame
- Still need better observability
- Connection pooling is subtle
- Should have caught in code review

#!/bin/bash
# landing-page.sh - Generate a complete landing page

PRODUCT="$1"
DESCRIPTION="$2"

{
  echo "Product: $PRODUCT"
  echo "Description: $DESCRIPTION"
} | onnai "create a landing page HTML:
- Hero with headline and CTA
- 3 feature sections (use emoji icons)
- Testimonial section (3 quotes)
- Pricing (3 tiers)
- FAQ (5 questions)
- Footer

Modern CSS, single file, mobile responsive." > index.html

open index.html 2>/dev/null || xdg-open index.html

./landing-page.sh "TaskFlow" "AI project management for remote teams"
./landing-page.sh "FreshBite" "Healthy meal kits delivered weekly"

#!/bin/bash
# md-to-site.sh - Convert markdown to website

CONTENT_DIR="${1:-.}"
OUTPUT_DIR="${2:-./site}"

mkdir -p "$OUTPUT_DIR"

# Generate CSS
onnai "create modern CSS for a documentation site" > "$OUTPUT_DIR/style.css"

# Convert each markdown file
for md in "$CONTENT_DIR"/*.md; do
  [ -f "$md" ] || continue
  BASENAME=$(basename "$md" .md)
  TITLE=$(head -1 "$md" | sed 's/^#* *//')
  
  {
    echo "<!DOCTYPE html><html><head><title>$TITLE</title>"
    echo "<link rel='stylesheet' href='style.css'></head><body><main>"
    pandoc "$md" 2>/dev/null || cat "$md" | onnai "convert markdown to HTML"
    echo "</main></body></html>"
  } > "$OUTPUT_DIR/${BASENAME}.html"
done

#!/bin/bash
# portfolio.sh - Personal portfolio site

{
  echo "Name: $1"
  echo "Role: $2"
  echo "Projects:"
  cat "$3"
} | onnai "create portfolio HTML:
- Hero with name, role, bio
- Projects grid
- Skills section
- Contact section
Dark mode, minimal, responsive." > portfolio.html

#!/bin/bash
# blog-gen.sh - Simple static blog

POSTS_DIR="${1:-./posts}"
OUTPUT_DIR="${2:-./blog}"
mkdir -p "$OUTPUT_DIR"

# Index page
{
  echo "Posts:"
  for post in "$POSTS_DIR"/*.md; do
    TITLE=$(head -1 "$post" | sed 's/^#* *//')
    echo "- $TITLE"
  done
} | onnai "blog index.html with post list, clean typography" > "$OUTPUT_DIR/index.html"

# Each post
for post in "$POSTS_DIR"/*.md; do
  SLUG=$(basename "$post" .md)
  {
    echo "Title: $(head -1 "$post")"
    echo "Content:"
    cat "$post"
  } | onnai "blog post HTML, reading time, share buttons" > "$OUTPUT_DIR/${SLUG}.html"
done

# Generate UI components
echo "pricing table with 3 tiers" | onnai "HTML component, scoped CSS" > pricing.html
echo "testimonial carousel" | onnai "HTML component" > testimonials.html
echo "newsletter signup form" | onnai "HTML component, accessible" > signup.html
echo "FAQ accordion" | onnai "HTML component with vanilla JS" > faq.html

#!/bin/bash
# site-gen.sh - Multi-page site from brief

BRIEF="$1"
OUTPUT_DIR="${2:-./website}"
mkdir -p "$OUTPUT_DIR/css"

# Plan the site
cat "$BRIEF" | onnai "list pages needed with sections" > "$OUTPUT_DIR/plan.md"

# Generate CSS
cat "$BRIEF" | onnai "create CSS: variables, typography, layout, responsive" > "$OUTPUT_DIR/css/style.css"

# Generate each page
for page in home about features pricing contact; do
  {
    cat "$BRIEF"
    echo "Generate the $page page"
  } | onnai "HTML page linking css/style.css" > "$OUTPUT_DIR/${page}.html"
done

mv "$OUTPUT_DIR/home.html" "$OUTPUT_DIR/index.html"

#!/bin/bash
# iterate.sh - Refine with feedback

{
  cat "$1"
  echo "---"
  echo "Feedback: $2"
} | onnai "update HTML based on feedback" > "${1}.new"

diff "$1" "${1}.new" | head -30
read -p "Apply? [y/N] " confirm
[ "$confirm" = "y" ] && mv "${1}.new" "$1"

./iterate.sh index.html "bigger hero, more whitespace"
./iterate.sh index.html "green color scheme"
./iterate.sh index.html "add button animations"

#!/bin/bash
# docs-gen.sh - Docs from code

for file in "$1"/*.{py,js,go}; do
  [ -f "$file" ] || continue
  NAME=$(basename "$file")
  cat "$file" | onnai "create documentation HTML:
- Overview
- Functions with params
- Usage examples" > "docs/${NAME%.*}.html"
done

# One-liners
echo "SaaS for dog walkers" | onnai "landing page HTML" > index.html
echo "Welcome new users" | onnai "HTML email, inline CSS" > welcome.html
echo "Launching soon" | onnai "coming soon page with email capture" > soon.html
echo "Developer blog" | onnai "creative 404 page" > 404.html

# GitHub Pages
cd site && git init && git add . && git commit -m "Deploy"
git remote add origin git@github.com:user/repo.git
git push -f origin main

# Netlify
netlify deploy --dir=./site --prod

# Surge
surge ./site mysite.surge.sh

# Vercel  
vercel ./site

#!/bin/bash
# website-workflow.sh - End to end

BRIEF="$1"
DOMAIN="$2"

# Generate
./site-gen.sh "$BRIEF" ./site

# Sitemap
{
  echo '<?xml version="1.0"?><urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">'
  find ./site -name "*.html" -exec echo "<url><loc>https://${DOMAIN}/{}</loc></url>" \;
  echo '</urlset>'
} > ./site/sitemap.xml

# Deploy
surge ./site "$DOMAIN"
echo "Live at https://$DOMAIN"

#!/bin/bash
# agent-loop.sh - Basic agent structure

while true; do
  # 1. Observe
  OBSERVATION=$(get_current_state)
  
  # 2. Think
  ACTION=$(echo "$OBSERVATION" | onnai "what should I do next? respond with exactly one command")
  
  # 3. Act
  eval "$ACTION"
  
  # 4. Check if done
  echo "$ACTION" | grep -q "DONE" && break
  
  sleep 1
done

#!/bin/bash
# organize-agent.sh - Sorts files into folders

TARGET="${1:-.}"
mkdir -p "$TARGET"/{documents,images,code,data,other}

cat > .context << 'EOF'
You are a file organizer. For each filename, respond with ONLY the category:
documents, images, code, data, or other
No explanation, just the single word.
EOF

for file in "$TARGET"/*; do
  [ -f "$file" ] || continue
  
  FILENAME=$(basename "$file")
  CATEGORY=$(echo "$FILENAME" | onnai "categorize this file")
  CATEGORY=$(echo "$CATEGORY" | tr -d '[:space:]' | tr '[:upper:]' '[:lower:]')
  
  # Validate category
  case "$CATEGORY" in
    documents|images|code|data|other)
      mv "$file" "$TARGET/$CATEGORY/"
      echo "Moved $FILENAME → $CATEGORY/"
      ;;
    *)
      mv "$file" "$TARGET/other/"
      echo "Moved $FILENAME → other/ (unknown category: $CATEGORY)"
      ;;
  esac
done

echo "Done. Summary:"
for dir in documents images code data other; do
  echo "  $dir: $(ls "$TARGET/$dir" 2>/dev/null | wc -l) files"
done

#!/bin/bash
# research-agent.sh - Investigates a topic iteratively

TOPIC="$1"
MAX_ITERATIONS="${2:-5}"
WORKDIR="./research-$(date +%s)"
mkdir -p "$WORKDIR"

cat > "$WORKDIR/.context" << EOF
You are a research agent investigating: $TOPIC
Be thorough. Ask follow-up questions. Identify gaps.
EOF

cd "$WORKDIR"

# Initial question
echo "$TOPIC" > current_question.txt
echo "# Research: $TOPIC" > findings.md
echo "" >> findings.md

for i in $(seq 1 $MAX_ITERATIONS); do
  echo "=== Iteration $i ==="
  
  QUESTION=$(cat current_question.txt)
  echo "Researching: $QUESTION"
  
  # Search (simulate with onnai, replace with real search)
  RESULTS=$(echo "$QUESTION" | onnai "provide key facts about this topic, cite sources if known")
  
  # Analyze results
  {
    echo "Question: $QUESTION"
    echo "Results: $RESULTS"
    echo "Previous findings:"
    cat findings.md
  } | onnai "analyze: what did we learn? what gaps remain? what should we investigate next?" > analysis.txt
  
  # Extract new findings
  cat analysis.txt | onnai "extract only the new facts learned, as bullet points" >> findings.md
  
  # Determine next question
  NEXT=$(cat analysis.txt | onnai "what's the single most important follow-up question? respond with just the question")
  
  # Check if done
  if echo "$NEXT" | grep -qi "sufficient\|complete\|no further"; then
    echo "Research complete."
    break
  fi
  
  echo "$NEXT" > current_question.txt
  sleep 2
done

echo "=== Final Report ==="
cat findings.md | onnai "synthesize into a coherent research summary" > final_report.md
cat final_report.md

#!/bin/bash
# review-agent.sh - Multi-pass code review

FILE="$1"

cat > .context << 'EOF'
You are a thorough code reviewer. Be specific. Cite line numbers.
EOF

echo "=== Reviewing: $FILE ==="

# Pass 1: Security
echo "## Security Review" > review.md
cat -n "$FILE" | onnai "find security issues: injection, auth, secrets, etc." >> review.md

# Pass 2: Bugs
echo -e "\n## Potential Bugs" >> review.md
cat -n "$FILE" | onnai "find bugs: off-by-one, null refs, race conditions, etc." >> review.md

# Pass 3: Performance
echo -e "\n## Performance Issues" >> review.md
cat -n "$FILE" | onnai "find performance issues: N+1, unnecessary loops, memory leaks" >> review.md

# Pass 4: Style
echo -e "\n## Style & Readability" >> review.md
cat -n "$FILE" | onnai "find style issues: naming, complexity, missing docs" >> review.md

# Prioritize
echo -e "\n## Priority Actions" >> review.md
cat review.md | onnai "list top 5 issues to fix, ranked by severity" >> review.md

cat review.md

#!/bin/bash
# debug-agent.sh - Iteratively debugs an issue

ERROR_LOG="$1"
CODEBASE="${2:-.}"
MAX_ATTEMPTS=5

cat > .context << 'EOF'
You are a debugging agent. Be methodical.
Respond with ONE action at a time in format:
ACTION: <inspect|hypothesis|test|fix|done>
TARGET: <file or component>
DETAILS: <what to do>
EOF

echo "=== Starting debug session ==="
echo "Error: $(head -5 "$ERROR_LOG")"

# Initialize state
echo "" > hypotheses.txt
echo "" > tested.txt

for attempt in $(seq 1 $MAX_ATTEMPTS); do
  echo "--- Attempt $attempt ---"
  
  # Build context
  {
    echo "=== ERROR ==="
    cat "$ERROR_LOG"
    echo ""
    echo "=== HYPOTHESES ==="
    cat hypotheses.txt
    echo ""
    echo "=== TESTED ==="
    cat tested.txt
  } > debug_context.txt
  
  # Get next action
  ACTION=$(cat debug_context.txt | onnai "what's the next debugging step?")
  echo "$ACTION"
  
  # Parse action
  ACTION_TYPE=$(echo "$ACTION" | grep "ACTION:" | cut -d: -f2 | tr -d ' ')
  TARGET=$(echo "$ACTION" | grep "TARGET:" | cut -d: -f2-)
  
  case "$ACTION_TYPE" in
    inspect)
      echo "Inspecting: $TARGET"
      if [ -f "$CODEBASE/$TARGET" ]; then
        cat -n "$CODEBASE/$TARGET" | onnai "analyze for issues related to: $(cat "$ERROR_LOG" | head -1)"
      else
        find "$CODEBASE" -name "*$TARGET*" -exec cat {} \;
      fi
      ;;
    hypothesis)
      echo "$ACTION" >> hypotheses.txt
      ;;
    test)
      echo "Test: $TARGET" >> tested.txt
      # In real agent, would run actual tests
      ;;
    fix)
      echo "=== SUGGESTED FIX ==="
      echo "$ACTION"
      ;;
    done)
      echo "Debug session complete."
      break
      ;;
  esac
  
  sleep 1
done

#!/bin/bash
# monitor-agent.sh - Watches logs and reacts

LOG_FILE="$1"
ALERT_CMD="${2:-echo ALERT:}"

cat > .context << 'EOF'
You are a log monitoring agent.
Classify each log batch as: normal, warning, critical
For critical: explain the issue in one line
Respond in format:
LEVEL: <normal|warning|critical>
SUMMARY: <one line if not normal>
EOF

echo "Monitoring: $LOG_FILE"
echo "Alert command: $ALERT_CMD"

tail -f "$LOG_FILE" | while read -r line; do
  # Batch lines (collect for 5 seconds)
  BATCH="$line"
  read -t 5 -r more && BATCH="$BATCH"$'\n'"$more"
  
  # Analyze
  ANALYSIS=$(echo "$BATCH" | onnai "analyze these log lines")
  LEVEL=$(echo "$ANALYSIS" | grep "LEVEL:" | cut -d: -f2 | tr -d ' ')
  SUMMARY=$(echo "$ANALYSIS" | grep "SUMMARY:" | cut -d: -f2-)
  
  case "$LEVEL" in
    critical)
      $ALERT_CMD "CRITICAL: $SUMMARY"
      echo "$BATCH" | onnai "suggest immediate remediation" 
      ;;
    warning)
      echo "⚠️  Warning: $SUMMARY"
      ;;
  esac
done

#!/bin/bash
# task-agent.sh - Breaks down and executes complex tasks

TASK="$1"

cat > .context << 'EOF'
You are a task execution agent with access to bash.
Break tasks into steps. Execute one at a time.
Respond in format:
THOUGHT: <reasoning>
ACTION: <bash command or DONE>
Only use safe, non-destructive commands.
EOF

echo "=== Task: $TASK ==="

HISTORY=""
STEP=0

while [ $STEP -lt 20 ]; do
  ((STEP++))
  
  # Plan next action
  RESPONSE=$({
    echo "Task: $TASK"
    echo "History:"
    echo "$HISTORY"
    echo "---"
    echo "What's the next step?"
  } | onnai)
  
  echo "Step $STEP:"
  echo "$RESPONSE"
  
  # Extract action
  ACTION=$(echo "$RESPONSE" | grep "ACTION:" | cut -d: -f2-)
  
  if echo "$ACTION" | grep -qi "DONE"; then
    echo "=== Task Complete ==="
    break
  fi
  
  # Safety check
  if echo "$ACTION" | grep -qE "rm -rf|sudo|mkfs|dd |:(){"; then
    echo "Blocked unsafe command: $ACTION"
    HISTORY="$HISTORY"$'\n'"Step $STEP: BLOCKED - $ACTION"
    continue
  fi
  
  # Execute
  echo "Executing: $ACTION"
  RESULT=$(eval "$ACTION" 2>&1 | head -50)
  echo "Result: $RESULT"
  
  HISTORY="$HISTORY"$'\n'"Step $STEP: $ACTION"$'\n'"Result: $RESULT"
  
  sleep 1
done

#!/bin/bash
# multi-agent.sh - Agents that talk to each other

PROBLEM="$1"

# Agent 1: Proposer
propose() {
  echo "$1" | onnai "propose a solution to this problem. be specific."
}

# Agent 2: Critic  
critique() {
  echo "$1" | onnai "find flaws in this proposal. be harsh but constructive."
}

# Agent 3: Synthesizer
synthesize() {
  echo "$1" | onnai "synthesize the proposal and critique into an improved solution"
}

echo "=== Problem: $PROBLEM ==="

PROPOSAL=$(propose "$PROBLEM")
echo -e "\n📝 Proposal:\n$PROPOSAL"

CRITICISM=$(critique "$PROPOSAL")
echo -e "\n🔍 Critique:\n$CRITICISM"

FINAL=$({
  echo "Original problem: $PROBLEM"
  echo "Proposal: $PROPOSAL"
  echo "Critique: $CRITICISM"
} | synthesize)
echo -e "\n✅ Final Solution:\n$FINAL"

#!/bin/bash
# coder-agent.sh - Writes code iteratively with tests

SPEC="$1"
LANGUAGE="${2:-python}"
OUTFILE="${3:-solution.$LANGUAGE}"

cat > .context << EOF
Language: $LANGUAGE
Write clean, tested, production-ready code.
EOF

echo "=== Building: $SPEC ==="

# Step 1: Design
echo "Designing..."
DESIGN=$(echo "$SPEC" | onnai "design the solution: list functions, data structures, edge cases")
echo "$DESIGN"

# Step 2: Initial implementation
echo "Implementing..."
{
  echo "Spec: $SPEC"
  echo "Design: $DESIGN"
} | onnai "write the implementation" > "$OUTFILE"

# Step 3: Generate tests
echo "Generating tests..."
cat "$OUTFILE" | onnai "write unit tests for this code" > "test_$OUTFILE"

# Step 4: Review and iterate
for i in 1 2 3; do
  echo "Review iteration $i..."
  
  ISSUES=$({
    echo "=== CODE ==="
    cat "$OUTFILE"
    echo "=== TESTS ==="
    cat "test_$OUTFILE"
  } | onnai "find bugs, edge cases, improvements. be specific.")
  
  if echo "$ISSUES" | grep -qi "no issues\|looks good\|none found"; then
    echo "Code approved!"
    break
  fi
  
  echo "Issues found: $ISSUES"
  
  # Fix issues
  {
    cat "$OUTFILE"
    echo "---"
    echo "Fix these issues: $ISSUES"
  } | onnai "output the corrected code" > "${OUTFILE}.new"
  mv "${OUTFILE}.new" "$OUTFILE"
done

echo "=== Done ==="
echo "Code: $OUTFILE"
echo "Tests: test_$OUTFILE"

# Edit crontab
crontab -e

# Daily summary at 9am
0 9 * * * /home/user/scripts/daily-summary.sh | mail -s "Daily Report" user@example.com

# Hourly log check
0 * * * * tail -100 /var/log/app.log | onnai "any issues?" >> /var/log/ai-monitor.log

# Weekly newsletter draft (Sunday 6pm)
0 18 * * 0 /home/user/scripts/weekly-newsletter.sh

# Monitor every 5 minutes, alert on issues
*/5 * * * * /home/user/scripts/health-check.sh

#!/bin/bash

{
  echo "=== Yesterday's Sales ==="
  cat /var/log/sales.log | grep "$(date -d yesterday +%Y-%m-%d)"
  
  echo "=== Errors ==="
  cat /var/log/app.log | grep -i error | tail -20
  
  echo "=== Server Stats ==="
  df -h
  free -h
} | onnai "write a brief daily ops summary, highlight anything concerning"

#!/bin/bash

STATUS=$(curl -s -o /dev/null -w "%{http_code}" https://yourapp.com/health)

if [ "$STATUS" != "200" ]; then
  echo "Health check failed: $STATUS" | onnai "write urgent alert" | \
    curl -X POST -d @- "https://hooks.slack.com/services/XXX"
fi

#!/bin/bash
# slack-send.sh

WEBHOOK_URL="https://hooks.slack.com/services/YOUR/WEBHOOK/URL"

send_slack() {
  curl -s -X POST "$WEBHOOK_URL" \
    -H "Content-Type: application/json" \
    -d "{\"text\": \"$1\"}"
}

MESSAGE=$(cat | onnai "make this a friendly Slack message")
send_slack "$MESSAGE"

echo "Build failed for main branch" | ./slack-send.sh
cat sales.log | onnai "summarize today" | ./slack-send.sh

#!/bin/bash
# slack-bot.sh - Requires jq, websocat

BOT_TOKEN="xoxb-your-bot-token"
WS_URL=$(curl -s "https://slack.com/api/rtm.connect?token=$BOT_TOKEN" | jq -r '.url')

websocat "$WS_URL" | while read -r event; do
  TYPE=$(echo "$event" | jq -r '.type')
  
  if [ "$TYPE" = "message" ]; then
    TEXT=$(echo "$event" | jq -r '.text')
    CHANNEL=$(echo "$event" | jq -r '.channel')
    
    if echo "$TEXT" | grep -q "<@$BOT_ID>"; then
      RESPONSE=$(echo "$TEXT" | onnai "respond helpfully and briefly")
      curl -s -X POST "https://slack.com/api/chat.postMessage" \
        -H "Authorization: Bearer $BOT_TOKEN" \
        -H "Content-Type: application/json" \
        -d "{\"channel\": \"$CHANNEL\", \"text\": \"$RESPONSE\"}"
    fi
  fi
done

#!/bin/bash
# discord-send.sh

WEBHOOK_URL="https://discord.com/api/webhooks/YOUR/WEBHOOK"

MESSAGE=$(cat | onnai "format for Discord, brief")

curl -s -X POST "$WEBHOOK_URL" \
  -H "Content-Type: application/json" \
  -d "{\"content\": \"$MESSAGE\"}"

#!/bin/bash
# process-inbox.sh

MAILDIR="$HOME/Maildir/new"

for mail in "$MAILDIR"/*; do
  [ -f "$mail" ] || continue
  
  FROM=$(grep -m1 "^From:" "$mail" | sed 's/From: //')
  SUBJECT=$(grep -m1 "^Subject:" "$mail" | sed 's/Subject: //')
  BODY=$(sed -n '/^$/,$p' "$mail" | tail -n +2)
  
  # Classify
  CATEGORY=$(echo "$SUBJECT $BODY" | head -c 1000 | \
    onnai "classify as: urgent, support, sales, spam")
  
  case "$CATEGORY" in
    urgent) echo "$SUBJECT from $FROM" | ./slack-send.sh ;;
    support) echo "$BODY" | onnai "draft helpful response" > "drafts/${FROM}_reply.txt" ;;
    spam) mv "$mail" "$HOME/Maildir/spam/" ;;
  esac
done