daemora 1.0.0

package/skills/apple-reminders.md

@@ -0,0 +1,189 @@
+---
+name: apple-reminders
+description: Create, read, complete, and manage Apple Reminders on macOS using AppleScript. Use when the user asks to add a reminder, set a due date, list reminders, mark as done, or manage reminder lists. macOS only. Syncs with iPhone via iCloud.
+triggers: reminder, reminders, add reminder, set reminder, due date, alert, remind me, reminder list, todo reminder, apple reminders
+---
+
+## When to Use
+
+✅ Create reminders with due dates/times, list pending reminders, mark complete, create reminder lists, set location-based reminders
+
+❌ Complex task management (use Things or Trello skill) — use Reminders for simple "remind me at X time" tasks
+
+## Create a Reminder
+
+```bash
+# Simple reminder (no due date)
+osascript << 'EOF'
+tell application "Reminders"
+    tell list "Reminders"
+        make new reminder with properties {name:"Buy groceries"}
+    end tell
+end tell
+EOF
+
+# Reminder with due date and time
+osascript << 'EOF'
+tell application "Reminders"
+    tell list "Reminders"
+        set dueDate to current date
+        set day of dueDate to 15
+        set month of dueDate to 3
+        set year of dueDate to 2026
+        set hours of dueDate to 9
+        set minutes of dueDate to 0
+        set seconds of dueDate to 0
+        make new reminder with properties {
+            name:"Call the dentist",
+            due date:dueDate,
+            remind me date:dueDate
+        }
+    end tell
+end tell
+EOF
+```
+
+## Create Reminder with Dynamic Date
+
+```python
+#!/usr/bin/env python3
+import subprocess
+from datetime import datetime, timedelta
+
+def create_reminder(title: str, notes: str = "", due: datetime = None, list_name: str = "Reminders"):
+    """Create a reminder. due=None means no due date."""
+    if due:
+        # AppleScript date format
+        due_str = due.strftime("%B %d, %Y %I:%M:%S %p")
+        date_block = f'''
+            set dueDate to date "{due_str}"
+            set due date of newReminder to dueDate
+            set remind me date of newReminder to dueDate
+        '''
+    else:
+        date_block = ""
+
+    # Escape quotes
+    title = title.replace('"', '\\"')
+    notes = notes.replace('"', '\\"')
+
+    script = f'''
+    tell application "Reminders"
+        tell list "{list_name}"
+            set newReminder to make new reminder with properties {{name:"{title}"}}
+            {f'set body of newReminder to "{notes}"' if notes else ""}
+            {date_block}
+        end tell
+    end tell
+    '''
+    result = subprocess.run(["osascript", "-e", script], capture_output=True, text=True)
+    if result.returncode == 0:
+        due_display = due.strftime("%a %b %d at %I:%M %p") if due else "no due date"
+        print(f"✅ Reminder: '{title}' ({due_display})")
+    else:
+        print(f"❌ Failed: {result.stderr}")
+
+# Examples
+create_reminder("Weekly team sync", due=datetime.now() + timedelta(days=1, hours=2))
+create_reminder("Pay rent", due=datetime(2026, 4, 1, 9, 0), list_name="Bills")
+create_reminder("Buy coffee beans")  # no due date
+```
+
+## List Pending Reminders
+
+```bash
+osascript << 'EOF'
+tell application "Reminders"
+    set output to ""
+    set pending to (reminders whose completed is false)
+    repeat with r in pending
+        set dueInfo to ""
+        if due date of r is not missing value then
+            set dueInfo to " [due: " & (due date of r as string) & "]"
+        end if
+        set output to output & name of r & dueInfo & "\n"
+    end repeat
+    if output is "" then return "No pending reminders"
+    return output
+end tell
+EOF
+```
+
+## List Reminders Due Today
+
+```python
+#!/usr/bin/env python3
+import subprocess
+from datetime import datetime, date
+
+script = '''
+tell application "Reminders"
+    set output to ""
+    repeat with r in reminders
+        if completed of r is false and due date of r is not missing value then
+            set output to output & name of r & "|" & (due date of r as string) & "\n"
+        end if
+    end repeat
+    return output
+end tell
+'''
+result = subprocess.run(["osascript", "-e", script], capture_output=True, text=True)
+lines = [l.strip() for l in result.stdout.strip().split("\n") if l.strip()]
+
+today = date.today()
+today_items = []
+for line in lines:
+    if "|" in line:
+        name, due_str = line.rsplit("|", 1)
+        # Parse AppleScript date string
+        try:
+            due = datetime.strptime(due_str.strip()[:10], "%A, %B")
+        except:
+            pass
+        today_items.append(f"• {name.strip()}")
+
+if today_items:
+    print("📅 Reminders due today:")
+    print("\n".join(today_items))
+else:
+    print("✅ No reminders due today")
+```
+
+## Mark Reminder Complete
+
+```bash
+osascript << 'EOF'
+tell application "Reminders"
+    set targetReminder to first reminder whose name is "Buy groceries"
+    set completed of targetReminder to true
+end tell
+EOF
+```
+
+## List All Reminder Lists
+
+```bash
+osascript -e 'tell application "Reminders" to get name of lists'
+```
+
+## Create a New Reminder List
+
+```bash
+osascript << 'EOF'
+tell application "Reminders"
+    make new list with properties {name:"Shopping", color:green}
+end tell
+EOF
+```
+
+## Response Format for Users
+
+When confirming reminders created, format clearly:
+
+```
+✅ Reminder set:
+  📌 Call the dentist
+  📅 Monday, March 16 at 9:00 AM
+  📋 List: Reminders
+  🔔 Alert: At time of reminder
+```

package/skills/camsnap.md

@@ -0,0 +1,162 @@
+---
+name: camsnap
+description: Capture photos or screenshots from the Mac camera or screen. Use when the user asks to take a photo, capture a webcam shot, take a selfie, capture the screen, or grab a camera frame. macOS only. Uses the built-in screenCapture tool for screen, and imagesnap CLI for webcam.
+triggers: take photo, camera, webcam, selfie, snap photo, capture camera, camsnap, take picture, camera shot, photo capture
+---
+
+## When to Use
+
+✅ Capture a webcam/camera photo, take a screenshot, capture a specific window, time-lapse photography, verify physical setup
+
+❌ Video recording — use ffmpeg (see video-frames skill); screen recording — use QuickTime or built-in tools
+
+## Screen Capture (built-in — no install needed)
+
+```python
+# Use the built-in screenCapture tool
+# screenCapture(path: string) → saves screenshot to path and returns it for vision analysis
+
+# Capture full screen
+screenCapture("/tmp/screen.png")
+
+# Then analyze with imageAnalysis
+imageAnalysis("/tmp/screen.png", "What is shown on the screen?")
+```
+
+## Webcam / Camera Capture
+
+```bash
+# Install imagesnap (small, fast, no dependencies)
+brew install imagesnap
+
+# Take a photo with default camera
+imagesnap /tmp/photo.jpg
+
+# Take photo with delay (gives time to position)
+imagesnap -w 3 /tmp/photo.jpg   # 3 second warmup
+
+# List available cameras
+imagesnap -l
+# → Video Devices:
+#   FaceTime HD Camera
+#   iPhone Camera (Continuity Camera)
+
+# Use specific camera
+imagesnap -d "iPhone Camera" /tmp/photo.jpg
+
+# Take multiple frames (burst)
+imagesnap -t 1 /tmp/burst  # 1 second between shots; creates burst-001.jpg, burst-002.jpg, etc.
+```
+
+## Python Wrapper
+
+```python
+#!/usr/bin/env python3
+import subprocess, os
+from pathlib import Path
+from datetime import datetime
+
+def capture_webcam(
+    output: str = None,
+    camera: str = None,
+    warmup: float = 1.5,
+    quality: str = "high"
+) -> str:
+    """
+    Capture a photo from the webcam.
+    Returns path to saved image.
+    """
+    if output is None:
+        ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+        output = f"/tmp/webcam_{ts}.jpg"
+
+    cmd = ["imagesnap", "-w", str(warmup)]
+    if camera:
+        cmd += ["-d", camera]
+    cmd.append(output)
+
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        raise RuntimeError(f"Camera capture failed: {result.stderr}")
+
+    size = os.path.getsize(output)
+    print(f"📸 Photo saved: {output} ({size//1024}KB)")
+    return output
+
+def list_cameras() -> list[str]:
+    """List available cameras."""
+    result = subprocess.run(["imagesnap", "-l"], capture_output=True, text=True)
+    cameras = []
+    for line in result.stdout.split('\n'):
+        if line.strip() and not line.startswith('Video'):
+            cameras.append(line.strip())
+    return cameras
+
+# Capture and analyze
+cameras = list_cameras()
+print(f"Available cameras: {cameras}")
+
+photo_path = capture_webcam(warmup=2.0)
+
+# Analyze the photo with vision
+# imageAnalysis(photo_path, "Describe what you see in this photo")
+```
+
+## Time-Lapse Capture
+
+```python
+#!/usr/bin/env python3
+"""Capture multiple photos over time."""
+import subprocess, time
+from pathlib import Path
+from datetime import datetime
+
+out_dir = Path("/tmp/timelapse")
+out_dir.mkdir(exist_ok=True)
+
+interval_seconds = 30   # photo every 30 seconds
+count = 20              # take 20 photos
+
+print(f"Starting time-lapse: {count} photos, every {interval_seconds}s")
+for i in range(count):
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+    path = out_dir / f"frame_{i+1:03d}_{ts}.jpg"
+    subprocess.run(["imagesnap", "-w", "0.5", str(path)], capture_output=True)
+    print(f"📸 {i+1}/{count}: {path.name}")
+    if i < count - 1:
+        time.sleep(interval_seconds)
+
+print(f"\n✅ {count} photos saved to {out_dir}")
+```
+
+## Combine Screen + Camera (Picture-in-Picture)
+
+```bash
+# Take both and combine with ffmpeg
+imagesnap -w 1 /tmp/webcam.jpg
+screencapture /tmp/screen.png
+
+# Overlay webcam in bottom-right corner of screen
+ffmpeg -i /tmp/screen.png -i /tmp/webcam.jpg \
+  -filter_complex "[1:v]scale=320:-1[cam]; [0:v][cam]overlay=W-w-20:H-h-20" \
+  /tmp/combined.jpg -y -loglevel quiet
+echo "Combined: /tmp/combined.jpg"
+open /tmp/combined.jpg
+```
+
+## After Capturing
+
+1. Report the saved path: "Photo saved to `/tmp/photo.jpg`"
+2. Auto-analyze if user asked to "look at" something via camera
+3. To send the image via channel: `sendFile("/tmp/photo.jpg", channel, sessionId)`
+4. To open for review on macOS: `executeCommand("open /tmp/photo.jpg")`
+
+## Error Handling
+
+| Error | Fix |
+|-------|-----|
+| `imagesnap: command not found` | `brew install imagesnap` |
+| `No cameras found` | Check System Settings → Privacy → Camera — grant permissions |
+| Black/dark photo | Increase warmup: `-w 3` (camera needs time to adjust exposure) |
+| Camera busy | Another app is using the camera; close FaceTime/Zoom/Photo Booth |
+| Permission denied | System Settings → Privacy & Security → Camera → enable Terminal |

package/skills/coding.md

@@ -0,0 +1,14 @@
+---
+name: coding
+description: Use when writing, debugging, or reviewing code
+triggers: code, function, bug, error, refactor, implement, class, module, typescript, javascript, python, api, endpoint, test, debug
+---
+You are an expert programmer. When working on code tasks:
+
+1. **Read before writing** — Always read existing files before making changes. Understand the codebase patterns first.
+2. **Edit, don't rewrite** — Use editFile for surgical changes. Never rewrite entire files unless asked.
+3. **Test after changes** — Run tests or verify your changes work after making them.
+4. **Follow existing patterns** — Match the existing code style, naming conventions, and architecture.
+5. **Explain your reasoning** — Briefly explain why you made each change.
+6. **Handle errors** — Add appropriate error handling but don't over-engineer.
+7. **Security first** — Never introduce SQL injection, XSS, command injection, or other vulnerabilities.

package/skills/documents.md

@@ -0,0 +1,13 @@
+---
+name: documents
+description: Use when creating documents, reports, or PDFs
+triggers: document, report, pdf, write up, summary, proposal, template, markdown, create doc
+---
+You are an expert technical writer. When creating documents:
+
+1. **Structure first** — Start with an outline (headings, sections) before writing content.
+2. **Use headings** — Organize with clear hierarchy: # Title, ## Section, ### Subsection.
+3. **Bullet points** — Use bullets for lists, steps, and multiple items.
+4. **Be concise** — Every sentence should add value. Remove filler words.
+5. **Format for audience** — Technical docs for developers, simple language for non-technical users.
+6. **Save properly** — Use createDocument with the right format (markdown or pdf).

package/skills/email.md

@@ -0,0 +1,13 @@
+---
+name: email
+description: Use when drafting, sending, or managing emails
+triggers: email, mail, send, draft, reply, compose, message, inbox
+---
+You are an expert email writer. When handling email tasks:
+
+1. **Professional tone** — Default to professional but friendly. Match the tone of the conversation.
+2. **Clear subject lines** — Write specific, actionable subject lines.
+3. **Brief and scannable** — Keep emails concise. Use bullet points for multiple items.
+4. **Call to action** — End with a clear next step or ask.
+5. **Proofread** — Check for typos and clarity before sending.
+6. **Confirm before sending** — Always confirm with the user before actually sending an email.

package/skills/gif-search.md

@@ -0,0 +1,196 @@
+---
+name: gif-search
+description: Search for GIFs, download and send animated GIFs, create GIFs from images or video clips. Use when the user asks for a GIF, wants to find a funny/reaction GIF, send a GIF, or convert something to a GIF. Searches Giphy/Tenor by default; can create GIFs from local video too.
+triggers: gif, find gif, send gif, reaction gif, funny gif, animated gif, search gif, giphy, tenor, make gif, create gif
+---
+
+## When to Use
+
+✅ Find and send reaction GIFs, search Giphy/Tenor by keyword, create GIFs from video clips or image sequences, convert media to GIF
+
+❌ Large video files → use video-frames skill instead; static images → just share the image directly
+
+## Search Giphy (requires free API key)
+
+```python
+#!/usr/bin/env python3
+"""Search Giphy for GIFs by keyword."""
+import os, json, urllib.request, urllib.parse
+from pathlib import Path
+
+GIPHY_KEY = os.environ.get("GIPHY_API_KEY", "")  # free key at developers.giphy.com
+
+def search_gif(query: str, limit: int = 5, rating: str = "g") -> list[dict]:
+    """Search Giphy. Returns list of GIF info dicts."""
+    if not GIPHY_KEY:
+        # Fall back to Giphy public beta key (rate-limited)
+        key = "dc6zaTOxFJmzC"
+    else:
+        key = GIPHY_KEY
+
+    params = urllib.parse.urlencode({
+        "q": query, "api_key": key,
+        "limit": limit, "rating": rating,
+        "lang": "en"
+    })
+    url = f"https://api.giphy.com/v1/gifs/search?{params}"
+    data = json.loads(urllib.request.urlopen(url).read())
+    return [
+        {
+            "title": g["title"],
+            "url":   g["images"]["original"]["url"],
+            "mp4":   g["images"]["original"]["mp4"],
+            "preview": g["images"]["fixed_height_small"]["url"],
+            "width": int(g["images"]["original"]["width"]),
+            "height": int(g["images"]["original"]["height"]),
+        }
+        for g in data.get("data", [])
+    ]
+
+def download_gif(url: str, output: str = None) -> str:
+    """Download a GIF to a local path."""
+    if not output:
+        from datetime import datetime
+        output = f"/tmp/gif_{datetime.now().strftime('%Y%m%d%H%M%S')}.gif"
+    urllib.request.urlretrieve(url, output)
+    size = Path(output).stat().st_size
+    print(f"✅ GIF downloaded: {output} ({size//1024}KB)")
+    return output
+
+# Search and get first result
+results = search_gif("excited celebration")
+if results:
+    g = results[0]
+    print(f"Found: {g['title']}")
+    path = download_gif(g["url"])
+    # Then: sendFile(path, channel, sessionId) to send via Telegram/Slack/Discord
+```
+
+## Search Tenor (no API key needed for basic use)
+
+```python
+#!/usr/bin/env python3
+import json, urllib.request, urllib.parse
+
+def search_tenor(query: str, limit: int = 5) -> list[dict]:
+    """Search Tenor GIFs. Uses public key."""
+    params = urllib.parse.urlencode({
+        "q": query,
+        "key": "LIVDSRZULELA",   # Tenor public demo key
+        "limit": limit,
+        "media_filter": "minimal",
+        "contentfilter": "low"
+    })
+    url = f"https://tenor.googleapis.com/v2/search?{params}"
+    data = json.loads(urllib.request.urlopen(url).read())
+    return [
+        {
+            "title": r.get("content_description", ""),
+            "url":   r["media_formats"]["gif"]["url"],
+            "mp4":   r["media_formats"].get("mp4", {}).get("url", ""),
+            "size":  r["media_formats"]["gif"].get("size", 0),
+        }
+        for r in data.get("results", [])
+    ]
+
+results = search_tenor("happy dance")
+for r in results[:3]:
+    print(f"  • {r['title'][:60]} ({r['size']//1024}KB)")
+    print(f"    {r['url']}")
+```
+
+## Create GIF from Video Clip
+
+```bash
+# Requires ffmpeg (brew install ffmpeg)
+VIDEO="/path/to/video.mp4"
+START="00:00:05"
+DURATION=3           # seconds
+OUTPUT="/tmp/clip.gif"
+WIDTH=480
+
+ffmpeg -ss "$START" -t "$DURATION" -i "$VIDEO" \
+  -vf "fps=10,scale=${WIDTH}:-1:flags=lanczos,split[s0][s1];[s0]palettegen=max_colors=128[p];[s1][p]paletteuse=dither=bayer" \
+  -loop 0 "$OUTPUT" -y -loglevel quiet
+
+SIZE=$(du -h "$OUTPUT" | cut -f1)
+echo "✅ GIF: $OUTPUT ($SIZE)"
+```
+
+## Create GIF from Image Sequence
+
+```bash
+# Convert a series of images to GIF
+INPUT_DIR="/tmp/frames"
+OUTPUT="/tmp/animation.gif"
+DELAY=10   # delay between frames (1/100 sec) — 10 = 100ms = 10fps
+
+# Using ImageMagick (brew install imagemagick)
+convert -delay $DELAY -loop 0 "${INPUT_DIR}"/*.png "$OUTPUT"
+
+# Or with ffmpeg (better quality)
+ffmpeg -framerate 10 -pattern_type glob -i "${INPUT_DIR}/*.png" \
+  -vf "scale=480:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" \
+  -loop 0 "$OUTPUT" -y -loglevel quiet
+
+echo "✅ GIF: $OUTPUT"
+```
+
+## Optimize GIF Size
+
+```bash
+# GIFs can be huge — optimize before sending
+INPUT="/tmp/original.gif"
+OUTPUT="/tmp/optimized.gif"
+
+# Using gifsicle (brew install gifsicle)
+gifsicle --optimize=3 --lossy=80 "$INPUT" -o "$OUTPUT"
+
+BEFORE=$(du -h "$INPUT" | cut -f1)
+AFTER=$(du -h "$OUTPUT" | cut -f1)
+echo "Before: $BEFORE → After: $AFTER"
+
+# Or reduce size by lowering resolution
+ffmpeg -i "$INPUT" -vf "scale=320:-1:flags=lanczos" "$OUTPUT" -y -loglevel quiet
+```
+
+## Full Workflow: Search → Download → Send
+
+```python
+#!/usr/bin/env python3
+"""Search for a GIF and prepare it to send via a channel."""
+
+def get_gif_for_message(query: str, channel: str = "telegram", session_id: str = "") -> str:
+    """
+    Search for a GIF matching the query, download it, return the local path.
+    Then caller uses sendFile(path, channel, session_id) to deliver it.
+    """
+    # Try Tenor first (no key needed), fall back to Giphy
+    results = search_tenor(query, limit=3)
+    if not results:
+        results = search_gif(query, limit=3)
+
+    if not results:
+        return None
+
+    # Pick first result
+    gif_url = results[0]["url"]
+    path = download_gif(gif_url)
+    return path
+
+# Example:
+path = get_gif_for_message("thumbs up success")
+if path:
+    print(f"Ready to send: {path}")
+    # sendFile(path, "telegram", session_id)
+```
+
+## Response Format
+
+When the user asks to send a GIF:
+1. Search with relevant keywords
+2. Download the best match
+3. Send via `sendFile(path, channel, sessionId)`
+4. Confirm: "Sent 🎉 GIF: [title]"
+
+If the channel doesn't support GIFs (plain text email), share the URL instead.