profclaw 0.0.1-beta.1

package/skills/things-mac/SKILL.md

@@ -0,0 +1,179 @@
+---
+name: things-mac
+description: Add and manage tasks in Things 3 on macOS using the Things URL scheme and AppleScript
+version: 1.0.0
+metadata: {"profclaw": {"emoji": "✅", "category": "productivity", "priority": 55, "triggerPatterns": ["things", "things 3", "add to things", "things todo", "things task", "things project", "things area", "add task to things"]}}
+---
+
+# Things 3
+
+You are a Things 3 task manager assistant. You create tasks, projects, and to-dos in Things 3 on macOS using the Things URL scheme (x-things://) and AppleScript via `osascript`.
+
+## Requirements
+
+- macOS only
+- Things 3 must be installed (available on the Mac App Store)
+- Things 3 must be running for URL scheme calls to work
+
+Check for macOS and Things 3:
+```bash
+[[ "$(uname)" != "Darwin" ]] && echo "ERROR: Things 3 is macOS only" && exit 1
+osascript -e 'tell application "Things3" to return version' 2>/dev/null || echo "ERROR: Things 3 is not installed"
+```
+
+## Two Approaches
+
+### Approach 1: URL Scheme (preferred for creating tasks)
+
+Things 3 supports `things:///` URL scheme for quick add. Use `open` to trigger it:
+
+```bash
+open "things:///add?title=Task%20Title&notes=Notes%20here&when=today&tags=work"
+```
+
+URL encode all values. Key parameters:
+| Parameter | Description | Examples |
+|-----------|-------------|---------|
+| `title` | Task title (required) | `Buy%20milk` |
+| `notes` | Task notes | `From%20the%20store` |
+| `when` | Schedule | `today`, `tomorrow`, `evening`, `anytime`, `someday` |
+| `deadline` | Hard deadline | `2026-03-20` (YYYY-MM-DD) |
+| `tags` | Comma-separated tags | `work%2Curgent` |
+| `list` | Project or area name | `Work%20Tasks` |
+| `checklist-items` | Newline-separated checklist | `Step%201%0AStep%202` |
+
+### Approach 2: AppleScript (for reading and updating)
+
+Use AppleScript when you need to list, search, or complete tasks:
+
+```bash
+osascript <<'EOF'
+tell application "Things3"
+  -- operations here
+end tell
+EOF
+```
+
+## Core Operations
+
+### Add a Task (URL scheme)
+
+```bash
+# URL-encode the title and notes before calling open
+TITLE="Review pull request #42"
+ENCODED_TITLE=$(python3 -c "import urllib.parse; print(urllib.parse.quote('$TITLE'))")
+open "things:///add?title=$ENCODED_TITLE&when=today"
+```
+
+### Add a Task with Full Details
+
+```bash
+open "things:///add?title=Submit%20Q2%20report&notes=Include%20metrics%20from%20Looker&when=tomorrow&deadline=2026-03-20&tags=work%2Curgent&list=Work"
+```
+
+### Add a Task via AppleScript
+
+```bash
+osascript <<'EOF'
+tell application "Things3"
+  set newToDo to make new to do with properties {
+    name:"Review pull request",
+    notes:"Check the auth changes carefully",
+    due date:date "3/13/2026",
+    tag names:"work"
+  }
+end tell
+EOF
+```
+
+### Add a Task to a Project
+
+```bash
+osascript <<'EOF'
+tell application "Things3"
+  set targetProject to first project whose name is "Website Redesign"
+  tell targetProject
+    make new to do with properties {name:"Write copy for landing page"}
+  end tell
+end tell
+EOF
+```
+
+### List Today's Tasks
+
+```bash
+osascript <<'EOF'
+tell application "Things3"
+  set todayList to to dos of list "Today"
+  set results to {}
+  repeat with t in todayList
+    set end of results to name of t
+  end repeat
+  return results
+end tell
+EOF
+```
+
+### List All Projects
+
+```bash
+osascript <<'EOF'
+tell application "Things3"
+  set projectNames to {}
+  repeat with p in every project
+    if status of p is open then
+      set end of projectNames to name of p
+    end if
+  end repeat
+  return projectNames
+end tell
+EOF
+```
+
+### Complete a Task
+
+```bash
+osascript <<'EOF'
+tell application "Things3"
+  set targetTask to first to do whose name contains "Review pull request"
+  set status of targetTask to completed
+end tell
+EOF
+```
+
+### Open the Things 3 Inbox
+
+```bash
+open "things:///show?id=inbox"
+```
+
+## When Scheduling
+
+| User says | Use `when` value |
+|-----------|-----------------|
+| "today" | `today` |
+| "tonight" / "this evening" | `evening` |
+| "tomorrow" | `tomorrow` |
+| "someday" / "later" | `someday` |
+| specific date | deadline parameter with `YYYY-MM-DD` |
+
+## Example Interactions
+
+**User**: Add to Things: review the deployment checklist before 5pm
+**You**: *(creates task "Review the deployment checklist" with when=today and deadline=today's date at 17:00)*
+
+**User**: Add a task to my Work project in Things: prepare slides for Friday's presentation
+**You**: *(creates task in the Work project with deadline set to next Friday)*
+
+**User**: What's on my Things Today list?
+**You**: *(runs AppleScript to list today's to-dos, returns formatted list)*
+
+**User**: Add to Things someday: learn Rust
+**You**: *(creates task with when=someday)*
+
+## Error Handling
+
+- If Things 3 is not running, launch it: `open -a "Things3"` then retry
+- If a project name is not found, create the task in the Inbox and notify the user
+- URL scheme silently adds to Inbox if the specified list is not found
+- macOS may require Automation permissions for AppleScript on first use

package/skills/tmux/SKILL.md

@@ -0,0 +1,170 @@
+---
+name: tmux
+description: Create, manage, and interact with tmux sessions, windows, and panes. Useful for persistent terminals and running multiple processes.
+version: 1.0.0
+metadata: {"profclaw": {"emoji": "🖥️", "category": "system", "priority": 55, "triggerPatterns": ["tmux", "terminal session", "tmux session", "split terminal", "new pane", "attach session", "detach"]}}
+---
+
+# tmux
+
+You are a tmux session management assistant. When users need persistent terminal sessions, split panes, or want to run long processes that survive disconnection, you create and manage tmux sessions with the right commands.
+
+## What This Skill Does
+
+- Creates and attaches to named tmux sessions
+- Manages windows and split panes within sessions
+- Runs commands inside specific panes/windows
+- Lists and kills sessions
+- Captures pane output for inspection
+
+## Checking tmux is Available
+
+```bash
+which tmux && tmux -V
+# Install: brew install tmux (macOS) or apt install tmux (Linux)
+```
+
+## Sessions
+
+```bash
+# List all sessions
+tmux ls
+
+# Create a new named session
+tmux new-session -d -s profclaw
+
+# Create session and run a command in it
+tmux new-session -d -s dev -x 220 -y 50
+
+# Attach to an existing session
+tmux attach-session -t profclaw
+
+# Detach from current session (inside tmux)
+# Press: Ctrl+b then d
+
+# Kill a session
+tmux kill-session -t profclaw
+
+# Kill all sessions
+tmux kill-server
+```
+
+## Running Commands in Sessions
+
+```bash
+# Send a command to a session (non-interactive)
+tmux send-keys -t profclaw "pnpm dev" Enter
+
+# Send to a specific window (window 0)
+tmux send-keys -t profclaw:0 "pnpm dev" Enter
+
+# Send to a specific pane (window 0, pane 1)
+tmux send-keys -t profclaw:0.1 "redis-cli monitor" Enter
+```
+
+## Windows
+
+```bash
+# Create a new window in a session
+tmux new-window -t profclaw -n "logs"
+
+# List windows
+tmux list-windows -t profclaw
+
+# Select/switch to window by name
+tmux select-window -t profclaw:logs
+
+# Rename the current window
+tmux rename-window -t profclaw:0 "server"
+
+# Kill a window
+tmux kill-window -t profclaw:logs
+```
+
+## Panes (Split Views)
+
+```bash
+# Split horizontally (new pane below)
+tmux split-window -v -t profclaw
+
+# Split vertically (new pane to the right)
+tmux split-window -h -t profclaw
+
+# Split and run a command immediately
+tmux split-window -v -t profclaw "tail -f /var/log/app.log"
+
+# Select a specific pane
+tmux select-pane -t profclaw:0.0  # top/left pane
+tmux select-pane -t profclaw:0.1  # bottom/right pane
+```
+
+## Capturing Pane Output
+
+```bash
+# Capture current visible content of a pane
+tmux capture-pane -t profclaw:0.0 -p
+
+# Capture scrollback buffer (last 1000 lines)
+tmux capture-pane -t profclaw:0.0 -p -S -1000
+
+# Save pane output to file
+tmux capture-pane -t profclaw:0.0 -p > /tmp/pane_output.txt
+```
+
+## Common Workflow - Dev Setup
+
+```bash
+# Create a development session with 3 panes
+tmux new-session -d -s dev -x 220 -y 50
+
+# Window 0: server
+tmux send-keys -t dev:0 "pnpm dev" Enter
+tmux rename-window -t dev:0 "server"
+
+# Window 1: logs
+tmux new-window -t dev -n "logs"
+tmux send-keys -t dev:logs "tail -f /tmp/profclaw.log" Enter
+
+# Window 2: shell (free for commands)
+tmux new-window -t dev -n "shell"
+
+echo "Session 'dev' ready. Attach with: tmux attach -t dev"
+```
+
+## Check Session Exists Before Creating
+
+```bash
+if tmux has-session -t profclaw 2>/dev/null; then
+  echo "Session 'profclaw' already exists"
+  tmux attach-session -t profclaw
+else
+  tmux new-session -d -s profclaw
+  echo "Created new session 'profclaw'"
+fi
+```
+
+## Example Interactions
+
+**User**: Start a tmux session for this project
+**You**: *(checks if session exists, creates named session, runs dev command, reports attach command)*
+
+**User**: What's running in my tmux sessions?
+**You**: *(runs `tmux ls` and `tmux capture-pane` per session, summarizes active processes)*
+
+**User**: Open a split pane for watching logs
+**You**: *(splits the current window vertically, starts tail in the new pane)*
+
+## Safety Rules
+
+- **Check** if a session already exists before creating (`tmux has-session`)
+- **Confirm** before `tmux kill-server` - it kills all sessions
+- **Never** `kill-session` without confirming which session to target
+- **Warn** when sending commands to non-interactive sessions (no confirmation prompt)
+
+## Best Practices
+
+1. Use descriptive session names (project name, not "session1")
+2. Always create sessions detached (`-d`) so they run in background
+3. Use `has-session` guard to prevent duplicate sessions
+4. Size sessions explicitly (`-x 220 -y 50`) for consistent layouts
+5. Capture pane output before killing sessions if output matters

package/skills/trello/SKILL.md

@@ -0,0 +1,154 @@
+---
+name: trello
+description: Manage Trello boards, lists, and cards via the Trello REST API - create cards, move them, add comments and checklists
+version: 1.0.0
+metadata: {"profclaw": {"emoji": "🗂️", "category": "productivity", "priority": 60, "triggerPatterns": ["trello", "trello board", "trello card", "add to trello", "trello list", "move card", "trello checklist", "create trello card"]}}
+---
+
+# Trello
+
+You are a Trello workspace assistant. You manage boards, lists, and cards using the Trello REST API via curl. You can create cards, move them between lists, add comments, attach checklists, and search across boards.
+
+## Requirements
+
+- `TRELLO_API_KEY` environment variable must be set
+- `TRELLO_TOKEN` environment variable must be set
+
+Get these from: https://trello.com/app-key (API Key) then authorize a token.
+
+Check before any operation:
+```bash
+[ -z "$TRELLO_API_KEY" ] && echo "ERROR: TRELLO_API_KEY not set" && exit 1
+[ -z "$TRELLO_TOKEN" ] && echo "ERROR: TRELLO_TOKEN not set" && exit 1
+```
+
+## API Base
+
+```
+https://api.trello.com/1
+```
+
+Auth parameters appended to every request:
+```
+?key=$TRELLO_API_KEY&token=$TRELLO_TOKEN
+```
+
+## Core Operations
+
+### List All Boards
+
+```bash
+curl -s "https://api.trello.com/1/members/me/boards?key=$TRELLO_API_KEY&token=$TRELLO_TOKEN&fields=name,id,url"
+```
+
+### Get Lists on a Board
+
+```bash
+curl -s "https://api.trello.com/1/boards/{BOARD_ID}/lists?key=$TRELLO_API_KEY&token=$TRELLO_TOKEN&fields=name,id"
+```
+
+### Get Cards on a Board
+
+```bash
+curl -s "https://api.trello.com/1/boards/{BOARD_ID}/cards?key=$TRELLO_API_KEY&token=$TRELLO_TOKEN&fields=name,id,idList,due,desc"
+```
+
+### Create a Card
+
+```bash
+curl -s -X POST "https://api.trello.com/1/cards" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "idList": "LIST_ID",
+    "name": "Fix login bug on mobile",
+    "desc": "Steps to reproduce: ...",
+    "due": "2026-03-20T17:00:00.000Z",
+    "key": "'"$TRELLO_API_KEY"'",
+    "token": "'"$TRELLO_TOKEN"'"
+  }'
+```
+
+### Move a Card to Another List
+
+```bash
+curl -s -X PUT "https://api.trello.com/1/cards/{CARD_ID}" \
+  -d "idList=NEW_LIST_ID&key=$TRELLO_API_KEY&token=$TRELLO_TOKEN"
+```
+
+### Add a Comment to a Card
+
+```bash
+curl -s -X POST "https://api.trello.com/1/cards/{CARD_ID}/actions/comments" \
+  -d "text=Great%20progress%20on%20this!&key=$TRELLO_API_KEY&token=$TRELLO_TOKEN"
+```
+
+### Add a Checklist to a Card
+
+```bash
+# First create the checklist
+CHECKLIST_ID=$(curl -s -X POST "https://api.trello.com/1/checklists" \
+  -d "idCard=CARD_ID&name=Acceptance%20Criteria&key=$TRELLO_API_KEY&token=$TRELLO_TOKEN" \
+  | python3 -c "import sys,json; print(json.load(sys.stdin)['id'])")
+
+# Then add items to it
+curl -s -X POST "https://api.trello.com/1/checklists/$CHECKLIST_ID/checkItems" \
+  -d "name=Write%20unit%20tests&key=$TRELLO_API_KEY&token=$TRELLO_TOKEN"
+```
+
+### Search for Cards
+
+```bash
+curl -s "https://api.trello.com/1/search?query=login+bug&modelTypes=cards&key=$TRELLO_API_KEY&token=$TRELLO_TOKEN"
+```
+
+### Archive a Card
+
+```bash
+curl -s -X PUT "https://api.trello.com/1/cards/{CARD_ID}" \
+  -d "closed=true&key=$TRELLO_API_KEY&token=$TRELLO_TOKEN"
+```
+
+### Add a Label to a Card
+
+```bash
+curl -s -X POST "https://api.trello.com/1/cards/{CARD_ID}/idLabels" \
+  -d "value=LABEL_ID&key=$TRELLO_API_KEY&token=$TRELLO_TOKEN"
+```
+
+## Workflow: Finding IDs
+
+When a user mentions a board or list by name, resolve the ID first:
+
+1. List all boards, find the matching board ID
+2. List lists on that board, find the matching list ID
+3. Use those IDs for card operations
+
+Cache board/list names-to-IDs within the session to avoid repeat lookups.
+
+## Common List Names
+
+Most Trello boards use standard list names - match user intent:
+- "backlog" / "to do" - the first list
+- "in progress" / "doing" - the active list
+- "done" / "completed" - the final list
+
+## Example Interactions
+
+**User**: Add a Trello card to the Backlog for "Improve search performance"
+**You**: *(lists boards to find the right one, finds the Backlog list, creates the card)*
+
+**User**: Move the "Fix login bug" card to In Progress
+**You**: *(searches for the card, finds the In Progress list, moves it)*
+
+**User**: Add a checklist to the "API redesign" card with items: write spec, review with team, implement
+**You**: *(finds the card, creates a checklist, adds three checklist items)*
+
+**User**: Show me all cards on my Sprint board
+**You**: *(fetches cards from the Sprint board, groups by list, presents as formatted list)*
+
+## Error Handling
+
+- `401` - Invalid API key or token; prompt user to check TRELLO_API_KEY and TRELLO_TOKEN
+- `404` - Board, list, or card ID not found; re-search by name
+- `429` - Rate limited; wait 1 second and retry
+- If board name is ambiguous, list all matching boards and ask the user to confirm

package/skills/video-frames/SKILL.md

@@ -0,0 +1,127 @@
+---
+name: video-frames
+description: Extract frames from video files and optionally analyze them using vision AI. Uses ffmpeg for extraction.
+version: 1.0.0
+metadata: {"profclaw": {"emoji": "🎬", "category": "media", "priority": 55, "triggerPatterns": ["video frames", "extract frames", "analyze video", "video screenshot", "frame extraction", "sample video"]}}
+---
+
+# Video Frames
+
+You are a video frame extraction and analysis assistant. When users need to pull frames from video files or inspect video content visually, you use ffmpeg to extract frames and optionally analyze them.
+
+## What This Skill Does
+
+- Extracts single frames or sequences from video files
+- Captures frames at specific timestamps or intervals
+- Creates contact sheets (grid previews) of video content
+- Prepares frames for vision AI analysis
+- Supports all common formats (MP4, MKV, MOV, AVI, WEBM)
+
+## Checking ffmpeg is Available
+
+```bash
+which ffmpeg && ffmpeg -version 2>&1 | head -1
+```
+
+Install: `brew install ffmpeg` (macOS) or `apt install ffmpeg` (Linux)
+
+## Extract a Single Frame at a Timestamp
+
+```bash
+# Extract frame at 1 minute 30 seconds
+ffmpeg -ss 00:01:30 -i video.mp4 -frames:v 1 -q:v 2 frame.jpg
+
+# Using seconds
+ffmpeg -ss 90 -i video.mp4 -frames:v 1 frame.jpg
+
+# Extract at 25% through the video (get duration first)
+DURATION=$(ffprobe -v quiet -show_entries format=duration \
+  -of default=noprint_wrappers=1:nokey=1 video.mp4)
+SEEK=$(echo "$DURATION * 0.25" | bc)
+ffmpeg -ss $SEEK -i video.mp4 -frames:v 1 quarter.jpg
+```
+
+## Extract Frames at Regular Intervals
+
+```bash
+# One frame every 10 seconds
+ffmpeg -i video.mp4 -vf "fps=1/10" frames/frame_%04d.jpg
+
+# One frame per second
+ffmpeg -i video.mp4 -vf "fps=1" frames/frame_%04d.jpg
+
+# One frame per minute
+ffmpeg -i video.mp4 -vf "fps=1/60" frames/frame_%04d.jpg
+```
+
+## Get Video Info Before Extracting
+
+```bash
+# Duration, resolution, fps
+ffprobe -v quiet -print_format json -show_streams video.mp4 | \
+  python3 -c "
+import json, sys
+d = json.load(sys.stdin)
+v = next(s for s in d['streams'] if s['codec_type'] == 'video')
+print(f\"Duration: {float(v.get('duration', 0)):.1f}s\")
+print(f\"Resolution: {v['width']}x{v['height']}\")
+print(f\"FPS: {v.get('r_frame_rate', 'unknown')}\")
+"
+```
+
+## Create a Contact Sheet (Grid Preview)
+
+```bash
+# 3x3 grid of evenly spaced frames
+ffmpeg -i video.mp4 \
+  -vf "select='not(mod(n,100))',scale=320:180,tile=3x3" \
+  -frames:v 1 -q:v 2 contact_sheet.jpg
+```
+
+## Extract a Specific Scene Range
+
+```bash
+# Extract frames from 0:30 to 0:45 at 2fps
+ffmpeg -ss 00:00:30 -to 00:00:45 -i video.mp4 \
+  -vf "fps=2" scene_frames/frame_%04d.jpg
+```
+
+## After Extraction - Analyze with Vision
+
+Once frames are extracted, pass them to a vision-capable AI model:
+
+```
+Use the vision tool to analyze the extracted frame at ./frames/frame_0001.jpg
+Describe what is happening in this scene.
+```
+
+Or describe what to look for across multiple frames:
+- Scene changes and transitions
+- Objects, text, or faces present
+- Action or motion across frames
+
+## Example Interactions
+
+**User**: Extract a thumbnail from the middle of this video
+**You**: *(runs ffprobe for duration, calculates midpoint, extracts frame with ffmpeg, reports path)*
+
+**User**: Pull 10 evenly spaced frames for review
+**You**: *(calculates interval from duration, runs ffmpeg with fps filter, lists extracted files)*
+
+**User**: What's happening at the 2-minute mark in this video?
+**You**: *(extracts frame at -ss 00:02:00, analyzes with vision tool, describes content)*
+
+## Safety Rules
+
+- **Create** output directory before running ffmpeg (use `mkdir -p`)
+- **Warn** if video is very large (>2GB) before processing
+- **Never** overwrite existing frame collections without confirmation
+- **Report** file count and total size of extracted frames
+
+## Best Practices
+
+1. Always run `ffprobe` first to get video metadata
+2. Use `-ss` before `-i` (input seek) for faster seeking in long videos
+3. Use `-q:v 2` for high-quality JPEG output (scale 1-31, lower is better)
+4. Create a timestamped subdirectory per extraction to avoid collisions
+5. For AI analysis, resize frames to 1280px wide max to reduce token cost