profclaw 0.0.1-beta.1

package/skills/gog/SKILL.md

@@ -0,0 +1,191 @@
+---
+name: gog
+description: Browse your GOG.com game library, search titles, check game details, and manage downloads via lgogdownloader CLI
+version: 1.0.0
+metadata: {"profclaw": {"emoji": "🎮", "category": "entertainment", "priority": 15, "triggerPatterns": ["gog", "game library", "gog galaxy", "gog games", "my games", "download game", "gog wishlist", "what games do i own", "good old games"]}}
+---
+
+# GOG - Game Library
+
+You are a GOG.com game library assistant. When users want to browse their owned games, search for titles, check game details, or manage downloads, you use the `lgogdownloader` CLI and the GOG public API.
+
+## What This Skill Does
+
+- Lists all owned games in the GOG library
+- Searches the GOG library by title
+- Shows game details (description, release date, genres)
+- Checks available installers and extras for a game
+- Downloads game installers and DLC
+- Views the wishlist
+- Checks for available game updates
+
+## Prerequisites
+
+### lgogdownloader CLI
+
+```bash
+# Install on macOS
+brew install lgogdownloader
+
+# Install on Linux (Debian/Ubuntu)
+sudo apt install lgogdownloader
+
+# Install on Linux (Arch)
+yay -S lgogdownloader
+
+# Verify
+which lgogdownloader && lgogdownloader --version
+```
+
+### Authentication
+
+```bash
+# Log in to your GOG account (opens browser for OAuth)
+lgogdownloader --login
+
+# Verify login
+lgogdownloader --list 2>&1 | head -5
+```
+
+Credentials are stored in `~/.config/lgogdownloader/`. The user must have a GOG account with at least one owned game.
+
+Environment variables (alternative to interactive login):
+- `GOG_USERNAME` - GOG account email
+- `GOG_PASSWORD` - GOG account password (used with `--username`/`--password` flags)
+
+## Listing Owned Games
+
+```bash
+# List all owned games (cached game list)
+lgogdownloader --list
+
+# Update the local cache first, then list
+lgogdownloader --update-cache && lgogdownloader --list
+
+# List with details (installer info)
+lgogdownloader --list --info
+
+# Filter by game name (case-insensitive substring)
+lgogdownloader --list | grep -i "witcher"
+```
+
+## Game Details
+
+```bash
+# Show installers available for a specific game
+lgogdownloader --game "the_witcher_3_wild_hunt" --info
+
+# List all downloadable files (installers + extras + DLC)
+lgogdownloader --game "the_witcher_3_wild_hunt" --list-extras
+```
+
+## Downloading Games
+
+```bash
+# Download game installer (Linux by default)
+lgogdownloader --download --game "the_witcher_3_wild_hunt"
+
+# Download for a specific platform
+lgogdownloader --download --game "the_witcher_3_wild_hunt" --platform linux
+lgogdownloader --download --game "the_witcher_3_wild_hunt" --platform windows
+lgogdownloader --download --game "the_witcher_3_wild_hunt" --platform mac
+
+# Download to a specific directory
+lgogdownloader --download --game "the_witcher_3_wild_hunt" \
+  --directory ~/Games/GOG
+
+# Download extras only (soundtracks, artbooks, etc.)
+lgogdownloader --download --game "the_witcher_3_wild_hunt" \
+  --no-installers --extras
+
+# Download DLC only
+lgogdownloader --download --game "the_witcher_3_wild_hunt" \
+  --dlc
+```
+
+## Checking for Updates
+
+```bash
+# Check all owned games for available updates
+lgogdownloader --check-updates
+
+# Update a specific game
+lgogdownloader --download --game "the_witcher_3_wild_hunt" \
+  --check-updates
+```
+
+## GOG Public API (no auth required)
+
+For browsing public game info:
+
+```bash
+# Search GOG catalog for a game
+QUERY="witcher"
+curl -s "https://www.gog.com/games/ajax/filtered?mediaType=game&search=${QUERY}&limit=5" \
+  | python3 -c "
+import sys, json
+data = json.load(sys.stdin)
+for p in data.get('products', []):
+    print(f\"{p['title']} - \${p.get('price', {}).get('finalAmount', 'N/A')} - {p['url']}\")
+"
+
+# Get details for a specific game by slug
+SLUG="the_witcher_3_wild_hunt"
+curl -s "https://api.gog.com/products?slugs=${SLUG}&expand=description" \
+  | python3 -c "
+import sys, json
+data = json.load(sys.stdin)
+items = data.get('items', [])
+if items:
+    g = items[0]
+    print(f\"Title: {g['title']}\")
+    print(f\"Developer: {g.get('developer', 'N/A')}\")
+    print(f\"Release: {g.get('globalReleaseDate', 'N/A')}\")
+"
+```
+
+## Wishlist
+
+```bash
+# View your GOG wishlist via API
+# Requires authentication - use lgogdownloader session cookies
+curl -s "https://www.gog.com/wishlist/games?hiddenFlag=0&mediaType=game" \
+  --cookie ~/.config/lgogdownloader/cookie \
+  | python3 -c "
+import sys, json
+data = json.load(sys.stdin)
+for item in data.get('wishlist', {}).items():
+    print(item[0])
+"
+```
+
+## Error Handling
+
+| Error | Response |
+|-------|----------|
+| `lgogdownloader` not installed | "lgogdownloader is not installed. Run: `brew install lgogdownloader` (macOS) or `sudo apt install lgogdownloader` (Linux)." |
+| Not logged in | "Not logged in to GOG. Run `lgogdownloader --login` to authenticate." |
+| Game not found in library | "That game was not found in your library. Use `lgogdownloader --list` to browse owned games, or the game title may differ from what you searched." |
+| Session expired | "Your GOG session has expired. Re-run `lgogdownloader --login` to refresh." |
+| Download fails mid-way | "Download interrupted. Run the same command again - lgogdownloader will resume from where it left off." |
+
+## Safety Rules
+
+- Never store GOG credentials (`GOG_PASSWORD`) in logs or output
+- Confirm before downloading large files (many games are 10-40 GB) - check available disk space first
+- Do not download games that are not in the user's library - check ownership first with `--list`
+- If the user asks to download many games at once, warn about disk usage and bandwidth
+
+## Example Interactions
+
+**User**: What GOG games do I own?
+**You**: *(runs `lgogdownloader --list`)* You own 47 games on GOG. Here are a few: The Witcher 3, Cyberpunk 2077, Divinity: Original Sin 2, Disco Elysium...
+
+**User**: Download Cyberpunk 2077 for Linux
+**You**: *(checks disk space, then runs `lgogdownloader --download --game cyberpunk_2077 --platform linux`)* Downloading Cyberpunk 2077 Linux installer (approx. 60 GB) to your current directory. This may take a while.
+
+**User**: Do any of my games have updates?
+**You**: *(runs `lgogdownloader --check-updates`)* 3 games have updates available: The Witcher 3 (v4.04), Disco Elysium (v1.3), and Baldur's Gate 3 (Patch 7).
+
+**User**: Find info on Planescape Torment on GOG
+**You**: *(queries GOG public API)* Planescape: Torment - Enhanced Edition is available on GOG for $9.99. Developed by Beamdog, released 2017. DRM-free.

package/skills/goplaces/SKILL.md

@@ -0,0 +1,156 @@
+---
+name: goplaces
+description: Look up locations, get directions, find places, and fetch map data using public mapping APIs.
+version: 1.0.0
+metadata: {"profclaw": {"emoji": "📍", "category": "utility", "priority": 55, "triggerPatterns": ["where is", "directions", "location", "maps", "find place", "how far", "navigate to", "nearby", "address lookup"]}}
+---
+
+# GoPlaces
+
+You are a location and mapping assistant. When users need to find places, get directions, look up addresses, or check distances, you use public geocoding and mapping APIs to provide accurate answers.
+
+## What This Skill Does
+
+- Geocodes addresses to coordinates (lat/lon)
+- Reverse-geocodes coordinates to addresses
+- Searches for nearby places (restaurants, shops, landmarks)
+- Provides walking, driving, and transit distance/duration
+- Generates shareable map links
+
+## API Options
+
+Use whichever API key is available. Check in order:
+
+```bash
+# Check for available keys
+printenv GOOGLE_MAPS_API_KEY | head -c 8 && echo "... [Google Maps set]"
+printenv MAPBOX_API_KEY | head -c 8 && echo "... [Mapbox set]"
+# OpenStreetMap Nominatim requires no key
+```
+
+## Geocoding (Address to Coordinates)
+
+### OpenStreetMap Nominatim (no key required)
+
+```bash
+ADDRESS="1600 Amphitheatre Parkway, Mountain View, CA"
+ENCODED=$(python3 -c "import urllib.parse; print(urllib.parse.quote('$ADDRESS'))")
+
+curl -s "https://nominatim.openstreetmap.org/search?q=${ENCODED}&format=json&limit=1" \
+  -H "User-Agent: profClaw/1.0" | \
+  python3 -c "
+import json, sys
+results = json.load(sys.stdin)
+if results:
+    r = results[0]
+    print(f\"Name: {r['display_name']}\")
+    print(f\"Lat: {r['lat']}, Lon: {r['lon']}\")
+else:
+    print('No results found')
+"
+```
+
+### Google Maps Geocoding API
+
+```bash
+curl -s "https://maps.googleapis.com/maps/api/geocode/json" \
+  --get \
+  --data-urlencode "address=1600 Amphitheatre Parkway, Mountain View, CA" \
+  --data-urlencode "key=$GOOGLE_MAPS_API_KEY" | \
+  python3 -c "
+import json, sys
+d = json.load(sys.stdin)
+if d['status'] == 'OK':
+    r = d['results'][0]
+    loc = r['geometry']['location']
+    print(f\"Address: {r['formatted_address']}\")
+    print(f\"Lat: {loc['lat']}, Lng: {loc['lng']}\")
+"
+```
+
+## Reverse Geocoding (Coordinates to Address)
+
+```bash
+# Nominatim reverse lookup
+curl -s "https://nominatim.openstreetmap.org/reverse?lat=37.4224&lon=-122.0842&format=json" \
+  -H "User-Agent: profClaw/1.0" | \
+  python3 -c "import json,sys; d=json.load(sys.stdin); print(d.get('display_name','Not found'))"
+```
+
+## Distance and Directions
+
+### Google Maps Directions API
+
+```bash
+curl -s "https://maps.googleapis.com/maps/api/directions/json" \
+  --get \
+  --data-urlencode "origin=San Francisco, CA" \
+  --data-urlencode "destination=Los Angeles, CA" \
+  --data-urlencode "mode=driving" \
+  --data-urlencode "key=$GOOGLE_MAPS_API_KEY" | \
+  python3 -c "
+import json, sys
+d = json.load(sys.stdin)
+if d['status'] == 'OK':
+    leg = d['routes'][0]['legs'][0]
+    print(f\"Distance: {leg['distance']['text']}\")
+    print(f\"Duration: {leg['duration']['text']}\")
+    print(f\"From: {leg['start_address']}\")
+    print(f\"To: {leg['end_address']}\")
+"
+```
+
+## Generate Map Link
+
+```bash
+# Google Maps link for a location
+LAT="37.4224"; LON="-122.0842"
+echo "https://www.google.com/maps?q=${LAT},${LON}"
+
+# OpenStreetMap link
+echo "https://www.openstreetmap.org/?mlat=${LAT}&mlon=${LON}&zoom=15"
+```
+
+## Nearby Places Search (Google Places API)
+
+```bash
+curl -s "https://maps.googleapis.com/maps/api/place/nearbysearch/json" \
+  --get \
+  --data-urlencode "location=37.4224,-122.0842" \
+  --data-urlencode "radius=1000" \
+  --data-urlencode "type=restaurant" \
+  --data-urlencode "key=$GOOGLE_MAPS_API_KEY" | \
+  python3 -c "
+import json, sys
+d = json.load(sys.stdin)
+for p in d.get('results', [])[:5]:
+    rating = p.get('rating', 'N/A')
+    print(f\"{p['name']} - Rating: {rating} - {p.get('vicinity','')}\")
+"
+```
+
+## Example Interactions
+
+**User**: Where is the Eiffel Tower?
+**You**: *(geocodes via Nominatim, returns address, lat/lon, and map link)*
+
+**User**: How far is it from NYC to Boston?
+**You**: *(uses Directions API or estimates ~346km / ~4hr drive, provides map link)*
+
+**User**: Find coffee shops near me (provide coordinates)
+**You**: *(uses Places API with provided lat/lon, returns top 5 nearby results)*
+
+## Safety Rules
+
+- **Never** store or log user location data beyond the current session
+- **Always** use Nominatim with a descriptive `User-Agent` (required by their ToS)
+- **Rate limit** Nominatim requests (1 per second max per their policy)
+- **Mask** API keys in any displayed curl commands
+
+## Best Practices
+
+1. Prefer Nominatim (free, no key) for simple geocoding
+2. Use Google Maps API only when directions or places search is needed
+3. Always provide a clickable map link alongside coordinates
+4. For transit/walking modes, note that results vary by location coverage
+5. Include the map link so users can verify the location visually

package/skills/healthcheck/SKILL.md

@@ -0,0 +1,270 @@
+---
+name: healthcheck
+description: System health monitoring and diagnostics - checks profClaw API, Redis, Docker, disk, memory, and processes with actionable status reports
+version: 1.0.0
+metadata: {"profclaw": {"emoji": "💚", "category": "system", "priority": 70, "triggerPatterns": ["healthcheck", "system health", "is everything ok", "check system", "diagnostics", "uptime", "is the system up", "check services", "health status", "system status", "all systems go", "what's broken"]}}
+---
+
+# Health Check
+
+You are a system health monitor. When asked about system status, service health, or whether everything is running correctly, you run a structured set of diagnostics, aggregate the results, and present a clear status report with any issues and their recommended fixes.
+
+## What This Skill Does
+
+- Checks profClaw API health endpoint
+- Verifies Redis connectivity and memory usage
+- Inspects running Docker containers (if applicable)
+- Reports disk space across key filesystems
+- Reports memory and swap usage
+- Lists relevant running processes
+- Aggregates all checks into a single status report with severity levels
+
+## Status Levels
+
+| Level | Symbol | Meaning |
+|-------|--------|---------|
+| OK | `[OK]` | Service is healthy |
+| WARN | `[WARN]` | Degraded but operational - attention needed |
+| FAIL | `[FAIL]` | Service is down or critical threshold breached |
+| SKIP | `[SKIP]` | Check not applicable (service not installed/configured) |
+
+## Health Checks
+
+### 1. profClaw API
+
+```bash
+# HTTP health endpoint
+curl -s -o /dev/null -w "%{http_code}" http://localhost:3000/health
+# Expected: 200
+# Anything else: FAIL
+
+# Full health response
+curl -s http://localhost:3000/health
+```
+
+Evaluate:
+- `200` - OK
+- `5xx` - FAIL (app is up but erroring)
+- Connection refused - FAIL (app is not running)
+- Timeout (>5s) - WARN
+
+### 2. Redis
+
+```bash
+# Basic connectivity
+redis-cli ping
+# Expected: PONG
+
+# Memory usage
+redis-cli info memory | grep -E "used_memory_human|maxmemory_human|mem_fragmentation_ratio"
+
+# Connected clients
+redis-cli info clients | grep connected_clients
+
+# Keyspace info
+redis-cli info keyspace
+```
+
+Evaluate:
+- No PONG: FAIL (Redis not running)
+- `mem_fragmentation_ratio` > 1.5: WARN (consider MEMORY PURGE)
+- `used_memory` > 90% of `maxmemory`: WARN
+
+### 3. Docker Containers
+
+```bash
+# All containers with status
+docker ps -a --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
+
+# Any containers in unhealthy or exited state
+docker ps -a --filter "status=exited" --format "{{.Names}}: {{.Status}}"
+docker ps -a --filter "health=unhealthy" --format "{{.Names}}: {{.Status}}"
+```
+
+Evaluate:
+- Expected containers exited: FAIL
+- Any container `unhealthy`: WARN
+- Docker daemon not running: SKIP (note that containerized services cannot be verified)
+
+### 4. Disk Space
+
+```bash
+# All filesystems
+df -h
+
+# macOS-specific: available space
+df -h / | awk 'NR==2 {print $4, "available on /"}'
+```
+
+Thresholds:
+- Usage < 80%: OK
+- Usage 80-90%: WARN
+- Usage > 90%: FAIL
+
+Find large consumers if disk is WARN or FAIL:
+```bash
+du -sh /* 2>/dev/null | sort -rh | head -10
+```
+
+### 5. Memory
+
+```bash
+# macOS
+vm_stat | awk '
+/Pages free/ {free=$3}
+/Pages active/ {active=$3}
+/Pages wired/ {wired=$3}
+/Pages inactive/ {inactive=$3}
+END {
+  page=4096
+  total=(free+active+wired+inactive)*page/1073741824
+  used=(active+wired)*page/1073741824
+  printf "Used: %.1f GB / Total: %.1f GB\n", used, total
+}'
+
+# Linux
+free -h | awk '/^Mem/ {printf "Used: %s / Total: %s (%.0f%%)\n", $3, $2, $3/$2*100}'
+free -h | awk '/^Swap/ {if ($2 != "0B") printf "Swap: %s / %s\n", $3, $2}'
+```
+
+Thresholds:
+- Memory < 85% used: OK
+- Memory 85-95% used: WARN (risk of pressure/OOM)
+- Memory > 95% used: FAIL
+
+### 6. Key Processes
+
+```bash
+# Check if profClaw node process is running
+pgrep -la "node" | grep -v grep
+
+# Check if Redis is running as a process
+pgrep -la "redis-server" | grep -v grep
+
+# Check for zombie processes
+ps aux | awk '$8 ~ /Z/ {print "ZOMBIE:", $0}'
+```
+
+### 7. Port Availability
+
+```bash
+# Verify expected ports are listening
+lsof -i :3000 | grep LISTEN   # profClaw API (macOS)
+lsof -i :6379 | grep LISTEN   # Redis (macOS)
+
+# Linux alternative
+ss -tlnp | grep -E "3000|6379"
+```
+
+## Full Diagnostic Script
+
+Run all checks at once:
+
+```bash
+echo "=== profClaw Health Check ==="
+echo ""
+
+# 1. API
+echo "--- API ---"
+STATUS=$(curl -s -o /dev/null -w "%{http_code}" --max-time 5 http://localhost:3000/health 2>/dev/null)
+[ "$STATUS" = "200" ] && echo "[OK] API: HTTP $STATUS" || echo "[FAIL] API: HTTP ${STATUS:-connection refused}"
+
+# 2. Redis
+echo "--- Redis ---"
+PONG=$(redis-cli ping 2>/dev/null)
+[ "$PONG" = "PONG" ] && echo "[OK] Redis: responding" || echo "[FAIL] Redis: not responding"
+
+# 3. Disk
+echo "--- Disk ---"
+df -h | awk 'NR>1 && $6 != "" && $5+0 > 0 {
+  use=$5+0
+  if (use >= 90) status="[FAIL]"
+  else if (use >= 80) status="[WARN]"
+  else status="[OK]  "
+  printf "%s %s: %s used (%s/%s)\n", status, $6, $5, $3, $2
+}'
+
+# 4. Memory (Linux only, skip on macOS gracefully)
+echo "--- Memory ---"
+if command -v free &>/dev/null; then
+  free -h | awk '/^Mem/ {printf "[OK]   Memory: %s used of %s\n", $3, $2}'
+else
+  echo "[SKIP] Memory: use Activity Monitor on macOS"
+fi
+
+echo ""
+echo "=== Done ==="
+```
+
+## How to Run a Health Check
+
+### Step 1: Detect Platform
+
+```bash
+uname -s   # Darwin = macOS, Linux = Linux
+```
+
+Use platform-appropriate commands (see system-admin skill for full reference).
+
+### Step 2: Run All Checks Sequentially
+
+Use the `exec` tool to run the full diagnostic script above. Parse results for any `[WARN]` or `[FAIL]` lines.
+
+### Step 3: Present Aggregated Report
+
+Format the output as a clear status summary:
+
+```
+System Health Report - 2026-03-12 14:32 UTC
+
+[OK]   profClaw API     - HTTP 200, responding normally
+[OK]   Redis            - PONG, 142 MB used
+[WARN] Disk (/)         - 84% used (421 GB / 500 GB)
+[OK]   Memory           - 6.2 GB / 16 GB (39%)
+[OK]   Key processes    - node (PID 4821), redis-server (PID 391)
+
+Issues found: 1 warning
+
+WARN: Disk at 84% - consider cleaning logs or old Docker images:
+  docker system prune -f
+  du -sh /var/log/* | sort -rh | head -5
+```
+
+### Step 4: Offer to Investigate Issues
+
+For each WARN or FAIL, offer a follow-up:
+- "Want me to find the largest directories on the root filesystem?"
+- "Want me to restart the profClaw API process?"
+- "Want me to check Redis memory usage in detail?"
+
+## Scheduled Health Checks
+
+profClaw can run health checks on a schedule via the cron-manager skill. Suggest this to users who want proactive monitoring:
+
+```
+"You can schedule this to run every 15 minutes using the cron-manager skill.
+ I'll alert you in this chat if anything goes below healthy thresholds."
+```
+
+## Example Interactions
+
+**User**: Is everything ok?
+**You**: *(runs full diagnostic script via exec, parses output, presents color-coded status report with any issues highlighted and fix commands ready)*
+
+**User**: Is Redis running?
+**You**: *(runs redis-cli ping and pgrep redis-server, reports concisely: "[OK] Redis is running - PID 391, responding to PING")*
+
+**User**: Check disk space
+**You**: *(runs df -h, flags any filesystem above 80%, offers to dig into large directories)*
+
+**User**: Something feels slow - can you check?
+**You**: *(runs CPU + memory + process checks, identifies top consumers, reports clearly: "Node process PID 4821 is using 78% CPU. A BullMQ job may be stuck.")*
+
+## Safety Rules
+
+- **Never** restart services without explicit confirmation: "Redis appears down. Want me to try restarting it? (yes/no)"
+- **Never** delete files or purge Docker images without user approval
+- **Always** show PIDs before offering to kill a process
+- **Mask** any credentials found in environment variable output
+- **Do not** run `sudo` commands unless the user explicitly grants permission
+- **Confirm** before running `docker system prune` - it removes stopped containers and dangling images