daemora 1.0.0

package/skills/tmux.md

@@ -0,0 +1,204 @@
+---
+name: tmux
+description: Create, manage, and control tmux sessions, windows, and panes. Send commands to running sessions, monitor output, split panes, run background processes in named sessions, and supervise long-running tasks. Use when the user asks to manage terminal sessions, run something in the background in tmux, monitor a running process, or control tmux.
+triggers: tmux, terminal session, background session, tmux window, tmux pane, split terminal, persistent session, attach session, detach session, monitor process
+---
+
+## When to Use
+
+✅ Running long background tasks in named sessions, monitoring running processes, splitting terminal workspace, sending input to interactive CLIs, managing multiple parallel jobs
+
+❌ Simple one-off background commands → use `executeCommand` with `background:true` directly
+
+## Check tmux is Available
+
+```bash
+which tmux && tmux -V || echo "tmux not found — install with: brew install tmux"
+```
+
+## Session Management
+
+```bash
+# List all sessions
+tmux ls
+# → main: 3 windows (created Mon Mar 3 09:00:00 2026) [220x50]
+
+# Create a new named session (detached, runs in background)
+tmux new-session -d -s mywork
+
+# Create session and run a command immediately
+tmux new-session -d -s server -x 220 -y 50 \; send-keys "npm run dev" Enter
+
+# Attach to a session (interactive)
+tmux attach -t mywork
+
+# Kill a session
+tmux kill-session -t mywork
+
+# Kill all sessions
+tmux kill-server
+```
+
+## Run Commands in a Session
+
+```bash
+# Send a command to an existing session
+tmux send-keys -t mywork "ls -la" Enter
+
+# Send to a specific window
+tmux send-keys -t mywork:0 "npm test" Enter
+
+# Send to a specific pane (window:pane)
+tmux send-keys -t mywork:0.1 "python3 script.py" Enter
+
+# Send without pressing Enter (useful for pre-filling input)
+tmux send-keys -t mywork "git commit -m '"
+```
+
+## Read Output from a Session
+
+```bash
+# Capture what's currently visible in a pane
+tmux capture-pane -t mywork -p
+
+# Capture last 200 lines (including scrollback)
+tmux capture-pane -t mywork -p -S -200
+
+# Save pane content to file
+tmux capture-pane -t mywork -p -S -500 > /tmp/session_output.txt
+
+# Check if a process is still running in a pane
+tmux capture-pane -t mywork -p | tail -5
+```
+
+## Python Helpers
+
+```python
+#!/usr/bin/env python3
+import subprocess, time
+
+def tmux_run(session: str, command: str, wait_seconds: float = 0.5) -> str:
+    """Send a command to a tmux session and capture output."""
+    subprocess.run(["tmux", "send-keys", "-t", session, command, "Enter"])
+    time.sleep(wait_seconds)
+    result = subprocess.run(
+        ["tmux", "capture-pane", "-t", session, "-p", "-S", "-100"],
+        capture_output=True, text=True
+    )
+    return result.stdout.strip()
+
+def tmux_session_exists(session: str) -> bool:
+    result = subprocess.run(["tmux", "has-session", "-t", session], capture_output=True)
+    return result.returncode == 0
+
+def tmux_get_output(session: str, lines: int = 50) -> str:
+    result = subprocess.run(
+        ["tmux", "capture-pane", "-t", session, "-p", "-S", f"-{lines}"],
+        capture_output=True, text=True
+    )
+    return result.stdout.strip()
+
+def tmux_ensure_session(session: str) -> None:
+    """Create session if it doesn't exist."""
+    if not tmux_session_exists(session):
+        subprocess.run(["tmux", "new-session", "-d", "-s", session, "-x", "220", "-y", "50"])
+        print(f"Created tmux session: {session}")
+    else:
+        print(f"Using existing session: {session}")
+
+# Example: run a dev server in tmux and monitor it
+tmux_ensure_session("devserver")
+output = tmux_run("devserver", "npm run dev", wait_seconds=2.0)
+print(f"Server output:\n{output}")
+
+# Later: check if server is still running
+current = tmux_get_output("devserver", lines=10)
+print(f"Current output:\n{current}")
+```
+
+## Split Panes (Parallel Work)
+
+```bash
+# Split current window vertically (left | right)
+tmux split-window -h -t mywork
+
+# Split horizontally (top / bottom)
+tmux split-window -v -t mywork
+
+# Run different commands in each pane
+tmux send-keys -t mywork:0.0 "npm run dev" Enter       # left pane: dev server
+tmux send-keys -t mywork:0.1 "npm run test -- --watch" Enter  # right pane: test watcher
+
+# Create a full monitoring layout
+tmux new-session -d -s monitor -x 220 -y 50
+tmux send-keys -t monitor "htop" Enter
+tmux split-window -h -t monitor
+tmux send-keys -t monitor:0.1 "tail -f /var/log/system.log" Enter
+tmux split-window -v -t monitor:0.1
+tmux send-keys -t monitor:0.2 "watch -n 2 df -h" Enter
+```
+
+## Monitor a Long-Running Task
+
+```python
+#!/usr/bin/env python3
+"""Start a task in tmux and poll until it's done."""
+import subprocess, time, re
+
+def run_and_monitor(session: str, command: str, done_pattern: str, timeout: int = 300):
+    """
+    Run command in tmux and wait until output matches done_pattern.
+    Returns final output.
+    """
+    # Ensure session exists
+    subprocess.run(["tmux", "new-session", "-d", "-s", session, "-x", "220", "-y", "50"],
+                   capture_output=True)  # ignore error if exists
+
+    subprocess.run(["tmux", "send-keys", "-t", session, command, "Enter"])
+    print(f"Started: {command}")
+
+    start = time.time()
+    while time.time() - start < timeout:
+        time.sleep(3)
+        result = subprocess.run(
+            ["tmux", "capture-pane", "-t", session, "-p", "-S", "-50"],
+            capture_output=True, text=True
+        )
+        output = result.stdout
+        if re.search(done_pattern, output, re.IGNORECASE):
+            print(f"✅ Done (matched: {done_pattern})")
+            return output
+
+    print(f"⚠️ Timed out after {timeout}s")
+    return subprocess.run(["tmux", "capture-pane", "-t", session, "-p", "-S", "-50"],
+                          capture_output=True, text=True).stdout
+
+# Example
+output = run_and_monitor(
+    session="build",
+    command="npm run build",
+    done_pattern=r"build complete|error|failed",
+    timeout=120
+)
+print(output[-500:])  # show last 500 chars
+```
+
+## Useful Shortcuts Reference
+
+```
+tmux new -s NAME        New session named NAME
+tmux ls                 List sessions
+tmux a -t NAME          Attach to session
+tmux kill-session -t N  Kill session
+
+Inside tmux (prefix is Ctrl+b by default):
+  d         Detach from session
+  c         New window
+  n/p       Next/previous window
+  %         Split vertically
+  "         Split horizontally
+  arrow     Move between panes
+  z         Zoom current pane (toggle)
+  q         Show pane numbers
+  [         Scroll mode (q to exit)
+```

package/skills/trello.md

@@ -0,0 +1,183 @@
+---
+name: trello
+description: Manage Trello boards, lists, and cards using the Trello REST API. Use when the user asks to create a Trello card, move a card, list boards, add a checklist, archive a card, or automate Trello workflows. Requires TRELLO_API_KEY and TRELLO_TOKEN environment variables.
+triggers: trello, kanban, trello card, trello board, create card, move card, trello list, trello checklist, trello archive, trello label
+---
+
+## When to Use
+
+✅ Create/update/move/archive cards, list boards and cards, add checklists, labels, due dates, comments, attach files, automate Trello workflows
+
+❌ Real-time push notifications (use Trello webhooks + a server endpoint) — use polling for monitoring instead
+
+## Setup
+
+```bash
+# Get your API key: https://trello.com/app-key
+# Generate token from that page
+
+export TRELLO_API_KEY="your_api_key"
+export TRELLO_TOKEN="your_token"
+
+# Quick test
+curl -s "https://api.trello.com/1/members/me/boards?key=${TRELLO_API_KEY}&token=${TRELLO_TOKEN}" \
+  | python3 -c "import sys,json; [print(b['name'], '→', b['id']) for b in json.load(sys.stdin)]"
+```
+
+## Python Helper (use for all Trello calls)
+
+```python
+#!/usr/bin/env python3
+import os, json, urllib.request, urllib.parse
+
+API_KEY = os.environ["TRELLO_API_KEY"]
+TOKEN   = os.environ["TRELLO_TOKEN"]
+BASE    = "https://api.trello.com/1"
+
+def trello(method: str, path: str, **kwargs) -> dict | list:
+    """Make a Trello API call. kwargs become query params for GET, form data for POST/PUT."""
+    params = {"key": API_KEY, "token": TOKEN, **kwargs}
+    url = f"{BASE}{path}"
+    if method == "GET":
+        url += "?" + urllib.parse.urlencode(params)
+        req = urllib.request.Request(url)
+    else:
+        data = urllib.parse.urlencode(params).encode()
+        req = urllib.request.Request(url, data=data, method=method)
+    with urllib.request.urlopen(req) as resp:
+        return json.loads(resp.read())
+```
+
+## List Boards
+
+```python
+boards = trello("GET", "/members/me/boards", fields="name,id,url,closed")
+open_boards = [b for b in boards if not b.get("closed")]
+for b in open_boards:
+    print(f"📋 {b['name']}  (id: {b['id']})")
+```
+
+## Get Lists on a Board
+
+```python
+board_id = "BOARD_ID_HERE"
+lists = trello("GET", f"/boards/{board_id}/lists", filter="open")
+for lst in lists:
+    print(f"  📁 {lst['name']}  (id: {lst['id']})")
+```
+
+## Get Cards on a Board / List
+
+```python
+# All cards on a board
+board_id = "BOARD_ID_HERE"
+cards = trello("GET", f"/boards/{board_id}/cards", fields="name,idList,due,desc,labels")
+for card in cards:
+    print(f"  🃏 {card['name']}  (due: {card.get('due', 'none')})")
+
+# Cards in a specific list
+list_id = "LIST_ID_HERE"
+cards = trello("GET", f"/lists/{list_id}/cards", fields="name,due,desc")
+```
+
+## Create a Card
+
+```python
+new_card = trello("POST", "/cards",
+    idList="LIST_ID_HERE",
+    name="Task: Fix login bug",
+    desc="## Description\nThe login form fails when email contains special characters.\n\n## Steps\n1. Go to /login\n2. Enter: user+test@example.com\n3. See error",
+    due="2026-03-15T09:00:00.000Z",  # ISO 8601
+    pos="top"  # or "bottom" or a position number
+)
+print(f"✅ Card created: {new_card['name']} → {new_card['url']}")
+```
+
+## Move Card to Another List
+
+```python
+card_id = "CARD_ID_HERE"
+target_list_id = "TARGET_LIST_ID"
+trello("PUT", f"/cards/{card_id}", idList=target_list_id)
+print("✅ Card moved")
+```
+
+## Add Checklist to Card
+
+```python
+card_id = "CARD_ID_HERE"
+
+# Create checklist
+checklist = trello("POST", "/checklists", idCard=card_id, name="Acceptance Criteria")
+
+# Add items
+for item in ["Tests pass", "Code reviewed", "Deployed to staging", "QA sign-off"]:
+    trello("POST", f"/checklists/{checklist['id']}/checkItems", name=item)
+
+print(f"✅ Checklist created with {4} items")
+```
+
+## Add Comment to Card
+
+```python
+card_id = "CARD_ID_HERE"
+trello("POST", f"/cards/{card_id}/actions/comments",
+    text="Investigated this issue — root cause is in auth.js:142. PR coming shortly.")
+```
+
+## Add Label to Card
+
+```python
+# First get or create a label
+board_id = "BOARD_ID_HERE"
+labels = trello("GET", f"/boards/{board_id}/labels")
+bug_label = next((l for l in labels if l.get("name") == "Bug"), None)
+
+if bug_label:
+    card_id = "CARD_ID_HERE"
+    trello("POST", f"/cards/{card_id}/idLabels", value=bug_label["id"])
+```
+
+## Archive (Close) a Card
+
+```python
+card_id = "CARD_ID_HERE"
+trello("PUT", f"/cards/{card_id}", closed="true")
+print("✅ Card archived")
+```
+
+## Full Workflow: Create Card from Task Description
+
+```python
+def add_task_to_trello(title: str, description: str, board_name: str = None, list_name: str = "To Do"):
+    """Find the right board/list and create a card."""
+    boards = trello("GET", "/members/me/boards", fields="name,id")
+    board = next((b for b in boards if board_name and board_name.lower() in b["name"].lower()), boards[0])
+
+    lists = trello("GET", f"/boards/{board['id']}/lists", filter="open")
+    target_list = next((l for l in lists if list_name.lower() in l["name"].lower()), lists[0])
+
+    card = trello("POST", "/cards",
+        idList=target_list["id"],
+        name=title,
+        desc=description,
+        pos="top"
+    )
+    return card["url"]
+
+url = add_task_to_trello(
+    "Research competitor pricing",
+    "## Goal\nAnalyze top 5 competitor pricing pages\n\n## Deliverable\nComparison spreadsheet",
+    board_name="Marketing"
+)
+print(f"Card created: {url}")
+```
+
+## Error Handling
+
+| Error | Fix |
+|-------|-----|
+| 401 Unauthorized | Check `TRELLO_API_KEY` and `TRELLO_TOKEN` are set and valid |
+| 404 Not Found | Board/list/card ID is wrong; list boards/lists first to get correct IDs |
+| 429 Rate Limited | Trello allows ~300 req/10s; add `time.sleep(0.1)` between bulk calls |
+| Card won't move | Verify target list is on same board as card |

package/skills/video-frames.md

@@ -0,0 +1,202 @@
+---
+name: video-frames
+description: Extract frames from video files, create thumbnails, generate GIFs from video clips, analyze video content frame-by-frame, and process video files. Use when the user asks to extract frames from a video, create a thumbnail, get a screenshot from a video at a specific timestamp, convert a clip to GIF, or analyze video content visually.
+triggers: video frames, extract frames, video thumbnail, screenshot from video, video to gif, analyze video, video clip, video timestamp, ffmpeg, frame extraction
+---
+
+## When to Use
+
+✅ Extract specific frames at timestamps, create video thumbnails, batch extract frames, convert clips to GIF, analyze video content visually, get video metadata
+
+❌ Full video editing, transcoding for streaming — use dedicated video editors for complex production work
+
+## Requirements
+
+```bash
+# Install ffmpeg (handles everything)
+brew install ffmpeg
+
+# Verify
+ffmpeg -version | head -1
+```
+
+## Get Video Info / Metadata
+
+```bash
+VIDEO="/path/to/video.mp4"
+
+# Full metadata
+ffprobe -v quiet -print_format json -show_format -show_streams "$VIDEO" | python3 -c "
+import sys, json
+d = json.load(sys.stdin)
+fmt = d['format']
+vid = next(s for s in d['streams'] if s['codec_type'] == 'video')
+print(f\"File:       {fmt['filename'].split('/')[-1]}\")
+print(f\"Duration:   {float(fmt['duration']):.1f}s ({float(fmt['duration'])/60:.1f} min)\")
+print(f\"Size:       {int(fmt['size'])/1024/1024:.1f} MB\")
+print(f\"Resolution: {vid['width']}x{vid['height']}\")
+print(f\"FPS:        {eval(vid['r_frame_rate']):.2f}\")
+print(f\"Codec:      {vid['codec_name']}\")
+"
+```
+
+## Extract Single Frame at Timestamp
+
+```bash
+VIDEO="/path/to/video.mp4"
+TIMESTAMP="00:01:30"   # HH:MM:SS or seconds like "90"
+OUTPUT="/tmp/frame.png"
+
+ffmpeg -ss "$TIMESTAMP" -i "$VIDEO" -vframes 1 -q:v 2 "$OUTPUT" -y -loglevel quiet
+echo "Frame saved: $OUTPUT"
+open "$OUTPUT"   # preview on macOS
+```
+
+## Extract Multiple Frames at Specific Times
+
+```python
+#!/usr/bin/env python3
+import subprocess
+from pathlib import Path
+
+video = "/path/to/video.mp4"
+timestamps = ["00:00:10", "00:00:30", "00:01:00", "00:02:00"]
+out_dir = Path("/tmp/video-frames")
+out_dir.mkdir(exist_ok=True)
+
+for i, ts in enumerate(timestamps):
+    out = out_dir / f"frame_{i+1:02d}_{ts.replace(':','')}.png"
+    subprocess.run([
+        "ffmpeg", "-ss", ts, "-i", video,
+        "-vframes", "1", "-q:v", "2",
+        str(out), "-y", "-loglevel", "quiet"
+    ])
+    print(f"✅ {ts} → {out}")
+
+print(f"\nAll frames in: {out_dir}")
+```
+
+## Extract Frames at Regular Intervals
+
+```bash
+VIDEO="/path/to/video.mp4"
+OUT_DIR="/tmp/frames"
+FPS=1   # 1 frame per second (use 0.5 for every 2 seconds, 2 for 2 per second)
+
+mkdir -p "$OUT_DIR"
+ffmpeg -i "$VIDEO" -vf "fps=${FPS}" "$OUT_DIR/frame_%04d.png" -loglevel quiet
+echo "Frames extracted to: $OUT_DIR"
+ls "$OUT_DIR" | wc -l | xargs echo "Total frames:"
+```
+
+## Create Thumbnail (Best Frame)
+
+```bash
+VIDEO="/path/to/video.mp4"
+OUTPUT="/tmp/thumbnail.jpg"
+
+# Take frame at 10% into the video (usually better than frame 1)
+DURATION=$(ffprobe -v quiet -show_entries format=duration -of csv=p=0 "$VIDEO")
+SEEK=$(python3 -c "print(f'{float('$DURATION') * 0.1:.2f}')")
+
+ffmpeg -ss "$SEEK" -i "$VIDEO" -vframes 1 -vf "scale=1280:-1" -q:v 2 "$OUTPUT" -y -loglevel quiet
+echo "Thumbnail: $OUTPUT"
+```
+
+## Convert Video Clip to GIF
+
+```bash
+VIDEO="/path/to/video.mp4"
+START="00:00:10"    # start time
+DURATION=5          # seconds
+OUTPUT="/tmp/clip.gif"
+WIDTH=480           # gif width (height auto-scaled)
+
+ffmpeg -ss "$START" -t "$DURATION" -i "$VIDEO" \
+  -vf "fps=12,scale=${WIDTH}:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" \
+  -loop 0 "$OUTPUT" -y -loglevel quiet
+
+SIZE=$(du -h "$OUTPUT" | cut -f1)
+echo "GIF created: $OUTPUT ($SIZE)"
+open "$OUTPUT"
+```
+
+## Analyze Video Content Visually
+
+```python
+#!/usr/bin/env python3
+"""Extract key frames and analyze with vision."""
+import subprocess
+from pathlib import Path
+
+def analyze_video(video_path: str, sample_count: int = 8) -> list[str]:
+    """
+    Extract evenly-spaced frames from video and return list of frame paths.
+    Use with imageAnalysis() tool to describe video content.
+    """
+    out_dir = Path("/tmp/video-analysis")
+    out_dir.mkdir(exist_ok=True)
+
+    # Get duration
+    result = subprocess.run(
+        ["ffprobe", "-v", "quiet", "-show_entries", "format=duration",
+         "-of", "csv=p=0", video_path],
+        capture_output=True, text=True
+    )
+    duration = float(result.stdout.strip())
+
+    # Extract evenly-spaced frames
+    frames = []
+    for i in range(sample_count):
+        timestamp = duration * (i + 1) / (sample_count + 1)
+        out = out_dir / f"frame_{i+1:02d}.jpg"
+        subprocess.run([
+            "ffmpeg", "-ss", str(timestamp), "-i", video_path,
+            "-vframes", "1", "-q:v", "3", str(out), "-y", "-loglevel", "quiet"
+        ])
+        if out.exists():
+            frames.append(str(out))
+
+    return frames
+
+# After getting frames, analyze each with imageAnalysis tool:
+frames = analyze_video("/path/to/video.mp4", sample_count=6)
+print(f"Extracted {len(frames)} frames for analysis")
+# Then: for frame in frames: imageAnalysis(frame, "Describe what's happening in this scene")
+```
+
+## Extract Audio from Video
+
+```bash
+VIDEO="/path/to/video.mp4"
+OUTPUT="/tmp/audio.mp3"
+
+ffmpeg -i "$VIDEO" -vn -acodec libmp3lame -q:a 2 "$OUTPUT" -y -loglevel quiet
+echo "Audio extracted: $OUTPUT"
+# Then use transcribeAudio() to transcribe it
+```
+
+## Create Contact Sheet (Grid of Frames)
+
+```bash
+VIDEO="/path/to/video.mp4"
+OUTPUT="/tmp/contact_sheet.jpg"
+
+# Extract 16 evenly-spaced frames and tile into a 4x4 grid
+DURATION=$(ffprobe -v quiet -show_entries format=duration -of csv=p=0 "$VIDEO")
+ffmpeg -i "$VIDEO" \
+  -vf "fps=16/${DURATION},scale=320:-1,tile=4x4" \
+  -frames:v 1 "$OUTPUT" -y -loglevel quiet
+echo "Contact sheet: $OUTPUT"
+open "$OUTPUT"
+```
+
+## Error Handling
+
+| Error | Fix |
+|-------|-----|
+| `ffmpeg: command not found` | `brew install ffmpeg` |
+| `Invalid data found` | Video file may be corrupted; try `ffprobe -v error "$VIDEO"` to check |
+| Blank/black frames | Video has black intro — use higher timestamp (e.g., 10% in) |
+| GIF too large | Lower fps (use 8 instead of 15), smaller width, shorter duration |
+| `No such file` | Check the video path is absolute and the file exists |