daemora 1.0.0

package/skills/spotify.md

@@ -0,0 +1,149 @@
+---
+name: spotify
+description: Control Spotify playback, search tracks/albums/playlists, manage queue, get now-playing info, and switch devices via the terminal. Use when the user asks to play music, pause, skip, search for a song, add to queue, or control Spotify. Requires Spotify Premium and spogo or spotify_player CLI.
+triggers: spotify, play music, pause music, skip song, next track, previous track, now playing, add to queue, spotify search, play album, play playlist, music control
+---
+
+## When to Use
+
+✅ Play/pause/skip tracks, search and play specific songs/albums/artists/playlists, get current playing status, manage queue, switch output device
+
+❌ Download music, access Spotify on behalf of other users, anything requiring Spotify free tier (Premium required for playback control)
+
+## Setup (one-time)
+
+```bash
+# Install spogo (preferred — simpler auth)
+brew tap steipete/tap && brew install spogo
+spogo auth import --browser chrome   # import from Chrome cookies
+spogo status   # verify it works
+
+# OR: install spotify_player (alternative)
+brew install spotify_player
+# First run opens Spotify auth in browser
+```
+
+## Playback Control
+
+```bash
+# Play / Pause
+spogo play
+spogo pause
+
+# Skip
+spogo next
+spogo prev
+
+# Current track info
+spogo status
+# → 🎵 Now Playing: Daft Punk — Get Lucky (Random Access Memories)
+#   ⏱ 2:34 / 4:08  🔊 65%  🔀 Shuffle: off
+
+# Volume
+spogo volume 80        # set to 80%
+spogo volume +10       # relative up
+spogo volume -10       # relative down
+```
+
+## Search & Play
+
+```bash
+# Play a specific track
+spogo search track "Get Lucky Daft Punk"
+# Shows results; then play by index:
+spogo play --track "spotify:track:2TpxZ7JUBn3uw46aR7qd6V"
+
+# Play an artist's top tracks
+spogo search artist "Arctic Monkeys"
+
+# Play a playlist
+spogo search playlist "lofi hip hop"
+
+# Play an album
+spogo search album "Random Access Memories"
+```
+
+## Queue Management
+
+```bash
+# Add current search result to queue
+spogo queue add "spotify:track:<id>"
+
+# View queue (spotify_player)
+spotify_player playback queue
+```
+
+## Device Management
+
+```bash
+# List available devices (speakers, phones, computers)
+spogo device list
+# → 1. MacBook Pro (active)
+#   2. Kitchen Speaker
+#   3. iPhone
+
+# Transfer playback to a device
+spogo device set "Kitchen Speaker"
+spogo device set 2   # by index
+```
+
+## Spotify Player (fallback commands)
+
+```bash
+# Status
+spotify_player playback status
+
+# Play/Pause/Skip
+spotify_player playback play
+spotify_player playback pause
+spotify_player playback next
+spotify_player playback previous
+
+# Like current track
+spotify_player like
+
+# Search
+spotify_player search "query"
+
+# Connect to device
+spotify_player connect
+```
+
+## Get Rich Now-Playing Info
+
+```python
+#!/usr/bin/env python3
+"""Get detailed now-playing info using spogo status output."""
+import subprocess, re
+
+result = subprocess.run(["spogo", "status"], capture_output=True, text=True)
+output = result.stdout.strip()
+if "Not playing" in output or result.returncode != 0:
+    print("⏸ Nothing is currently playing")
+else:
+    print(f"🎵 {output}")
+```
+
+## Error Handling
+
+| Error | Fix |
+|-------|-----|
+| `auth failed` | Re-run `spogo auth import --browser chrome` (cookies expired) |
+| `no active device` | Open Spotify app first, play something manually, then control via CLI |
+| `premium required` | Spotify playback control requires Premium |
+| `command not found` | Install with `brew install spogo` |
+| `rate limited` | Wait 30s; Spotify API has rate limits on rapid commands |
+
+## Response Format
+
+When reporting now-playing status, format it clearly:
+
+```
+🎵 Now Playing
+Track:   Get Lucky
+Artist:  Daft Punk
+Album:   Random Access Memories
+Progress: 2:34 / 4:08
+Volume:  65% 🔊
+Device:  MacBook Pro
+```

package/skills/summarize.md

@@ -0,0 +1,230 @@
+---
+name: summarize
+description: Summarize long documents, articles, PDFs, web pages, emails, chat threads, meeting notes, codebases, or any large text content. Use when the user asks to summarize something, make it shorter, give a TL;DR, extract key points, or condense a document. Can handle files, URLs, and pasted content.
+triggers: summarize, summary, tldr, tl;dr, condense, key points, brief, shorten, digest, recap, highlights, executive summary, abstract, overview
+---
+
+## When to Use
+
+✅ Summarizing articles, documents, PDFs, emails, long threads, meeting notes, code reviews, research papers, YouTube transcripts, Slack threads
+
+❌ Summarizing real-time data or live events — fetch the content first, then summarize
+
+## Summarization Levels
+
+Choose based on what the user needs:
+
+| Level | Output | Use Case |
+|-------|--------|---------|
+| **TL;DR** | 1-3 sentences | Quick status check, skimming |
+| **Key Points** | 5-10 bullets | Decision making, sharing |
+| **Executive Summary** | 2-3 paragraphs | Briefing leadership |
+| **Detailed Summary** | Structured sections | Replacing reading the full doc |
+| **Action Items** | Bullet list of tasks | After meetings, emails |
+
+## Summarize a URL
+
+```python
+# Fetch page content, then summarize
+# (Uses built-in webFetch tool — the model reads the page and summarizes)
+
+# Strategy for long pages:
+# 1. webFetch(url) → get the content
+# 2. If content > 4000 words: extract the main article body, skip nav/footer
+# 3. Structure the summary based on what the user asked for
+```
+
+## Summarize a File
+
+```python
+#!/usr/bin/env python3
+from pathlib import Path
+
+def read_for_summary(path: str, max_chars: int = 50000) -> str:
+    """Read file content for summarization."""
+    p = Path(path)
+    suffix = p.suffix.lower()
+
+    if suffix in ('.txt', '.md', '.rst', '.log'):
+        content = p.read_text(encoding='utf-8', errors='ignore')
+
+    elif suffix == '.pdf':
+        # Use pdfplumber if available
+        try:
+            import pdfplumber
+            with pdfplumber.open(path) as pdf:
+                content = "\n\n".join(
+                    f"[Page {i+1}]\n{page.extract_text() or ''}"
+                    for i, page in enumerate(pdf.pages)
+                )
+        except ImportError:
+            # Fall back to pdftotext (brew install poppler)
+            import subprocess
+            result = subprocess.run(["pdftotext", path, "-"], capture_output=True, text=True)
+            content = result.stdout
+
+    elif suffix in ('.docx',):
+        import subprocess
+        result = subprocess.run(["pandoc", path, "-t", "plain"], capture_output=True, text=True)
+        content = result.stdout
+
+    elif suffix in ('.json',):
+        import json
+        data = json.loads(p.read_text())
+        content = json.dumps(data, indent=2)
+
+    elif suffix in ('.csv',):
+        lines = p.read_text().split('\n')
+        headers = lines[0] if lines else ""
+        content = f"CSV with {len(lines)-1} rows.\nHeaders: {headers}\n\nFirst 10 rows:\n" + '\n'.join(lines[1:11])
+
+    else:
+        content = p.read_text(encoding='utf-8', errors='ignore')
+
+    # Truncate if too long (keep start + end for context)
+    if len(content) > max_chars:
+        half = max_chars // 2
+        content = (content[:half] +
+                   f"\n\n[... {len(content) - max_chars} characters truncated ...]\n\n" +
+                   content[-half:])
+    return content
+
+# Read the file and pass to the model for summarization
+content = read_for_summary("/path/to/document.pdf")
+print(f"Ready to summarize: {len(content)} chars")
+```
+
+## Summarize Long Email Thread
+
+```python
+#!/usr/bin/env python3
+def parse_email_thread(raw_email: str) -> list[dict]:
+    """Extract individual messages from an email thread."""
+    messages = []
+    # Split on common email separators
+    import re
+    parts = re.split(r'\n-{10,}\n|On .+ wrote:\n', raw_email)
+    for i, part in enumerate(parts):
+        lines = part.strip().split('\n')
+        # Try to extract From/Date
+        from_line = next((l for l in lines[:5] if l.startswith('From:')), f"Message {i+1}")
+        body = '\n'.join(lines[3:])  # skip headers
+        messages.append({"from": from_line, "body": body[:500]})
+    return messages
+
+# Format for summarization
+def format_thread_for_summary(messages: list[dict]) -> str:
+    return "\n\n---\n\n".join(
+        f"**{m['from']}**\n{m['body']}"
+        for m in messages
+    )
+```
+
+## Summary Output Templates
+
+Use these structures when presenting summaries:
+
+### TL;DR
+```
+**TL;DR:** [1-2 sentences capturing the absolute core message]
+```
+
+### Key Points
+```
+**Key Points:**
+• [Most important insight]
+• [Second key point]
+• [Third key point]
+• [Fourth key point]
+• [Fifth key point]
+
+**Bottom line:** [One sentence conclusion or recommendation]
+```
+
+### Executive Summary
+```
+**Executive Summary**
+
+**What:** [What this document/meeting/thread is about — 1 sentence]
+
+**Key Findings:**
+[2-3 sentences of the most important content]
+
+**Decisions / Actions:**
+• [Decision or action item 1]
+• [Decision or action item 2]
+
+**Next Steps:**
+• [What happens next]
+```
+
+### Meeting / Call Recap
+```
+**Meeting Recap — [Date] — [Topic]**
+**Attendees:** [names]
+
+**Discussed:**
+• [Topic 1]
+• [Topic 2]
+
+**Decisions Made:**
+• [Decision 1]
+
+**Action Items:**
+• [Person] → [Task] by [Date]
+• [Person] → [Task]
+```
+
+## Summarizing Code / PRs / Diffs
+
+When summarizing code or a git diff:
+
+```bash
+# Get a diff to summarize
+git diff main..feature-branch --stat
+git log main..feature-branch --oneline
+
+# For a large diff, summarize by file:
+git diff main..feature-branch -- src/ | head -200
+```
+
+Structure code summary as:
+```
+**Changes Summary**
+- Files changed: N
+- Lines added: +X / removed: -Y
+
+**What changed:**
+• [Feature or component]: [what was done]
+• [Another area]: [what was done]
+
+**Why (from commit messages):** [inferred purpose]
+**Risk level:** Low / Medium / High — [brief reason]
+```
+
+## Chunking Strategy for Very Long Content
+
+When content exceeds context limits, use this strategy:
+
+```python
+def chunk_for_summary(text: str, chunk_size: int = 8000) -> list[str]:
+    """Split text into overlapping chunks for multi-pass summarization."""
+    chunks = []
+    overlap = 200  # chars overlap between chunks
+    start = 0
+    while start < len(text):
+        end = min(start + chunk_size, len(text))
+        # Try to end at a paragraph boundary
+        if end < len(text):
+            last_para = text.rfind('\n\n', start, end)
+            if last_para > start + chunk_size // 2:
+                end = last_para
+        chunks.append(text[start:end])
+        start = end - overlap
+    return chunks
+
+# Strategy:
+# 1. Summarize each chunk individually
+# 2. Combine chunk summaries
+# 3. Summarize the combined summaries → final summary
+```

package/skills/things.md

@@ -0,0 +1,199 @@
+---
+name: things
+description: Manage Things 3 tasks, projects, and areas on macOS. Create todos with due dates, deadlines, checklists, tags, and notes. List inbox, today, upcoming, and anytime tasks. Search and update existing tasks. Use when the user asks to add a task to Things, check their to-do list, create a project, or manage Things 3. macOS only — requires Things 3 app installed.
+triggers: things, things 3, add task, todo, to-do, create task, things inbox, things today, upcoming tasks, things project, things area, things tag
+---
+
+## When to Use
+
+✅ Add todos with dates/tags/projects, read inbox/today/upcoming, search tasks, move to a project, mark complete, create checklists
+
+❌ Complex project management across teams (use Trello) — Things is personal task management; no API, no web access
+
+## Requirements
+
+- macOS with Things 3 installed (`brew install --cask things`)
+- For read operations: grant Full Disk Access to Terminal/Daemora in System Settings → Privacy & Security
+- For write operations: Things URL scheme (no extra permissions needed)
+
+## Read Tasks
+
+```bash
+# Find Things 3 database
+THINGS_DB=$(find ~/Library/Group\ Containers -name "*.sqlite3" -path "*Things3*" 2>/dev/null | head -1)
+echo "DB: $THINGS_DB"
+
+# List today's tasks
+sqlite3 "$THINGS_DB" "
+SELECT title, dueDate, notes
+FROM TMTask
+WHERE status = 0
+  AND (startDate <= strftime('%s','now') OR startDate IS NULL)
+  AND trashed = 0
+ORDER BY dueDate ASC
+LIMIT 20;"
+```
+
+## Python Helper (Read + Write)
+
+```python
+#!/usr/bin/env python3
+import subprocess, glob, sqlite3, os, urllib.parse
+from datetime import datetime, date
+from pathlib import Path
+
+# ── Read: direct SQLite access ─────────────────────────────────────────────
+
+def find_db() -> str:
+    """Locate Things 3 SQLite database."""
+    patterns = [
+        os.path.expanduser("~/Library/Group Containers/*/Things/Database5/main.sqlite"),
+        os.path.expanduser("~/Library/Group Containers/*/ThingsData-*/Things/Database5/main.sqlite"),
+    ]
+    for p in patterns:
+        matches = glob.glob(p)
+        if matches:
+            return matches[0]
+    raise FileNotFoundError("Things 3 database not found. Make sure Things 3 is installed and has been opened at least once.")
+
+def get_tasks(area: str = None, tag: str = None, limit: int = 30) -> list[dict]:
+    """Get pending tasks from Things 3."""
+    db_path = find_db()
+    conn = sqlite3.connect(db_path)
+    conn.row_factory = sqlite3.Row
+    cur = conn.cursor()
+
+    query = """
+        SELECT t.uuid, t.title, t.notes, t.dueDate, t.deadline,
+               p.title as project, a.title as area
+        FROM TMTask t
+        LEFT JOIN TMTask p ON t.project = p.uuid
+        LEFT JOIN TMArea a ON t.area = a.uuid
+        WHERE t.status = 0 AND t.trashed = 0 AND t.type = 0
+    """
+    params = []
+    if area:
+        query += " AND a.title LIKE ?"
+        params.append(f"%{area}%")
+    if tag:
+        query += """ AND t.uuid IN (
+            SELECT task FROM TMTaskTag tt
+            JOIN TMTag tg ON tt.tag = tg.uuid
+            WHERE tg.title LIKE ?)"""
+        params.append(f"%{tag}%")
+    query += f" ORDER BY t.dueDate ASC NULLS LAST LIMIT {limit}"
+
+    rows = cur.execute(query, params).fetchall()
+    conn.close()
+    return [dict(r) for r in rows]
+
+def get_today() -> list[dict]:
+    """Get tasks scheduled for today or overdue."""
+    db_path = find_db()
+    today_ts = int(datetime.combine(date.today(), datetime.min.time()).timestamp())
+    conn = sqlite3.connect(db_path)
+    conn.row_factory = sqlite3.Row
+    cur = conn.cursor()
+    rows = cur.execute("""
+        SELECT t.uuid, t.title, t.notes, t.dueDate, t.deadline
+        FROM TMTask t
+        WHERE t.status = 0 AND t.trashed = 0 AND t.type = 0
+          AND t.startDate IS NOT NULL AND t.startDate <= ?
+        ORDER BY t.dueDate ASC NULLS LAST
+    """, (today_ts,)).fetchall()
+    conn.close()
+    return [dict(r) for r in rows]
+
+# ── Write: Things URL scheme ────────────────────────────────────────────────
+
+def add_task(
+    title: str,
+    notes: str = "",
+    when: str = "",          # "today", "tomorrow", "evening", "anytime", "someday", or "YYYY-MM-DD"
+    deadline: str = "",      # "YYYY-MM-DD"
+    tags: list[str] = None,
+    list_name: str = "",     # project or area name
+    checklist: list[str] = None,
+    heading: str = "",
+) -> str:
+    """Add a task to Things 3 using the URL scheme."""
+    params = {"title": title}
+    if notes:       params["notes"]    = notes
+    if when:        params["when"]     = when
+    if deadline:    params["deadline"] = deadline
+    if tags:        params["tags"]     = ",".join(tags)
+    if list_name:   params["list"]     = list_name
+    if heading:     params["heading"]  = heading
+    if checklist:
+        params["checklist-items"] = "\n".join(checklist)
+
+    encoded = urllib.parse.urlencode(params)
+    url = f"things:///add?{encoded}"
+    subprocess.run(["open", url])
+    return url
+
+def add_project(title: str, notes: str = "", area: str = "", when: str = "") -> None:
+    """Create a new project in Things 3."""
+    params = {"title": title}
+    if notes: params["notes"] = notes
+    if area:  params["area"]  = area
+    if when:  params["when"]  = when
+    encoded = urllib.parse.urlencode(params)
+    subprocess.run(["open", f"things:///add-project?{encoded}"])
+```
+
+## Usage Examples
+
+```python
+# Add a simple task
+add_task("Buy groceries")
+
+# Task with date and tags
+add_task(
+    "Quarterly report",
+    notes="See shared doc in Drive",
+    when="2026-03-15",
+    deadline="2026-03-20",
+    tags=["work", "report"],
+    list_name="Q1 Planning"
+)
+
+# Task with checklist
+add_task(
+    "Deploy v2.0",
+    checklist=["Run test suite", "Update CHANGELOG", "Tag release", "Deploy to prod", "Notify team"],
+    list_name="Engineering",
+    when="today"
+)
+
+# Read today's tasks
+tasks = get_today()
+print(f"📋 Today ({len(tasks)} tasks):")
+for t in tasks:
+    print(f"  □ {t['title']}")
+
+# Read tasks in a project
+tasks = get_tasks(area="Work")
+for t in tasks:
+    print(f"  □ {t['title']} [{t.get('project', 'no project')}]")
+```
+
+## `when` Values
+
+| Value | Meaning |
+|-------|---------|
+| `today` | Scheduled for today |
+| `tomorrow` | Tomorrow |
+| `evening` | This evening |
+| `anytime` | Anytime (no date) |
+| `someday` | Someday |
+| `YYYY-MM-DD` | Specific date |
+
+## Error Handling
+
+| Error | Fix |
+|-------|-----|
+| DB not found | Open Things 3 first; try `find ~/Library -name "*.sqlite3" 2>/dev/null \| grep -i things` |
+| Permission denied on DB | System Settings → Privacy & Security → Full Disk Access → add Terminal |
+| URL scheme not working | Ensure Things 3 is installed (`ls /Applications/Things3.app`) |
+| Task not appearing | Things syncs on open; click "Things" in dock to bring to front |