daemora 1.0.1 → 1.0.3

package/skills/research.md

@@ -5,9 +5,9 @@ triggers: research, search, find, look up, what is, how does, explain, learn, in
 ---
 You are an expert researcher. When doing research tasks:
 
-1. **Search first** — Use webSearch to find relevant information before answering.
-2. **Multiple sources** — Check at least 2-3 sources to verify information.
-3. **Cite sources** — Include URLs and source names in your response.
-4. **Be current** — Prefer recent sources over older ones.
-5. **Summarize clearly** — Present findings in a structured, easy-to-read format.
-6. **Distinguish fact from opinion** — Clearly mark what is established fact vs. interpretation.
+1. **Search first** - Use webSearch to find relevant information before answering.
+2. **Multiple sources** - Check at least 2-3 sources to verify information.
+3. **Cite sources** - Include URLs and source names in your response.
+4. **Be current** - Prefer recent sources over older ones.
+5. **Summarize clearly** - Present findings in a structured, easy-to-read format.
+6. **Distinguish fact from opinion** - Clearly mark what is established fact vs. interpretation.

package/skills/skill-creator.md

@@ -1,142 +1,66 @@
 ---
 name: skill-creator
-description: Create new Daemora skills. Use when the user asks to create a new skill, package a capability, teach the agent a new behavior, or add a new skill file. A skill is a Markdown file in the skills/ directory that gets auto-loaded when matching triggers are detected.
+description: Create new Daemora skills. Use when the user asks to create a new skill, package a capability, teach the agent a new behavior, or add a new skill file.
 triggers: create skill, new skill, add skill, make skill, package skill, teach agent, skill creator, write skill
+metadata: {"daemora": {"emoji": "🛠️"}}
 ---
 
-## What Is a Skill
+## What is a skill
 
-A skill is a `.md` file in the `skills/` directory. When a user's task matches the skill's `triggers`, the skill's instructions are injected into the agent's system prompt for that task. Skills give the agent specialized knowledge, commands, and workflows for specific domains.
+A `.md` file in `skills/`. When a task matches the skill's `triggers`, the skill's content is injected into the system prompt for that task.
 
-## Skill File Format
+## Skill format
 
 ```markdown
 ---
-name: skill-name                    # unique slug, lowercase-hyphen
-description: One sentence describing WHAT this skill does and WHEN to use it.
-  Include the specific trigger phrases. Be comprehensive — the description
-  is how the agent decides whether to load this skill.
+name: skill-name
+description: What this skill does and WHEN to use it. Include trigger phrases - this is how the agent decides to load it.
 triggers: keyword1, keyword2, phrase, another phrase
+metadata: {"daemora": {"emoji": "🔧", "requires": {"bins": ["tool-name"]}, "install": ["brew install tool-name"], "os": ["darwin"]}}
 ---
 
-## When to Use
+## When to use
 
-✅ Specific cases where this skill applies
-❌ Cases where it does NOT apply (prevents false triggers)
+✅ Cases where this skill applies
+❌ Cases where it does NOT apply
 
-## Core Instructions
+## Core behavior
 
-[Domain-specific knowledge, commands, workflows]
+[What to do, what commands to run, how to respond]
 
-## Examples / Commands
+## Common commands
 
-[Concrete, working examples with real commands the agent can copy-paste]
+[Brief command examples - 2-5 lines, not full scripts]
 
-## Error Handling
+## Errors
 
-[What to do when things go wrong]
+| Error | Fix |
+|-------|-----|
+| ... | ... |
 ```
 
-## Creation Process
-
-### Step 1 — Gather requirements
-
-Ask (or infer from context):
-- What specific task should this skill handle?
-- What tools/commands/APIs does it use?
-- Does it require any external tools to be installed?
-- What platform does it run on (macOS/Linux/all)?
-- What are the "don't use this for" cases?
-
-### Step 2 — Design the skill
-
-Plan what to include:
-- **Trigger keywords**: think of every way a user might ask for this — colloquial terms, technical terms, action verbs
-- **Core commands**: real, tested commands with correct flags
-- **Error cases**: the 3-5 most common failure modes and their fixes
-- **Response format**: how should the agent present results to the user
-
-### Step 3 — Write and save
-
-```python
-#!/usr/bin/env python3
-"""Create a new Daemora skill file."""
-import re
-from pathlib import Path
-
-SKILLS_DIR = Path(__file__).parent.parent / "skills"
-
-def create_skill(name: str, description: str, triggers: list[str], content: str) -> Path:
-    """
-    name:        slug like "my-skill"
-    description: full description for triggering
-    triggers:    list of trigger keywords/phrases
-    content:     markdown body of the skill (without frontmatter)
-    """
-    # Validate name
-    if not re.match(r'^[a-z0-9-]+$', name):
-        raise ValueError(f"Skill name must be lowercase-hyphen: {name}")
-
-    trigger_str = ", ".join(triggers)
-    frontmatter = f"""---
-name: {name}
-description: {description}
-triggers: {trigger_str}
----
-
-"""
-    skill_path = SKILLS_DIR / f"{name}.md"
-    if skill_path.exists():
-        print(f"⚠️ Skill already exists: {skill_path}")
-        overwrite = input("Overwrite? (y/N): ").lower() == "y"
-        if not overwrite:
-            return skill_path
-
-    skill_path.write_text(frontmatter + content, encoding="utf-8")
-    print(f"✅ Skill created: {skill_path}")
-    return skill_path
-```
+## Creation process
 
-### Step 4 — Reload skills
+1. **Understand the domain** - what tools/commands/APIs does it use? Platform requirements?
+2. **Choose good triggers** - every way a user might ask: colloquial + technical + action verbs
+3. **Write behavioral instructions** - what to DO, not code templates to copy-paste
+4. **Include brief command examples** - 2-5 lines max per example
+5. **Save as** `skills/skill-name.md`
 
-After creating a skill:
+## After creating
 
 ```bash
 curl -s -X POST http://localhost:8081/skills/reload
-# → {"loaded": 12, "skills": ["coding", "research", ..., "new-skill"]}
-```
-
-Or restart the agent: `daemora start`
-
-## Skill Quality Checklist
-
-Before finalizing a skill, verify:
-
-- [ ] `description` clearly states WHAT the skill does and the key trigger phrases
-- [ ] `triggers` covers all reasonable ways a user would ask for this
-- [ ] Has "When to Use / When NOT to Use" section
-- [ ] All commands are real and tested — no fictional examples
-- [ ] Platform requirements noted (macOS-only, requires X installed, etc.)
-- [ ] Error handling covers the most common failure modes
-- [ ] No duplicate of existing skills — check `ls skills/`
-
-## Example: Creating a "Trello" Skill
-
-```
-name: trello
-description: Manage Trello boards, lists, and cards via the Trello REST API...
-triggers: trello, kanban board, create card, move card, trello list...
+# → {"loaded": 22, "skills": [..., "new-skill"]}
 ```
 
-Content should include:
-1. API auth setup (`TRELLO_API_KEY` + `TRELLO_TOKEN`)
-2. Get boards/lists/cards commands
-3. Create/move/archive card commands
-4. Webhook setup for automation
+Or restart: `daemora start`
 
-## Do NOT Create Skills For
+## Checklist before saving
 
-- One-time tasks (just do the task directly)
-- Things the agent already handles with its 36 built-in tools
-- Duplicates of existing skills (check `skills/` first)
-- Platform-specific things on wrong platform (e.g., Apple Notes skill on Linux)
+- [ ] `description` includes the key trigger phrases
+- [ ] `triggers` covers all reasonable ways a user would ask
+- [ ] Body is behavioral instructions, not code templates to copy-paste
+- [ ] Commands are real - no invented flags or fictional APIs
+- [ ] Platform requirements noted (macOS-only, requires X, etc.)
+- [ ] Not a duplicate of an existing skill (`ls skills/`)

package/skills/spotify.md

@@ -13,7 +13,7 @@ triggers: spotify, play music, pause music, skip song, next track, previous trac
 ## Setup (one-time)
 
 ```bash
-# Install spogo (preferred — simpler auth)
+# 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
@@ -36,7 +36,7 @@ spogo prev
 
 # Current track info
 spogo status
-# → 🎵 Now Playing: Daft Punk — Get Lucky (Random Access Memories)
+# → 🎵 Now Playing: Daft Punk - Get Lucky (Random Access Memories)
 #   ⏱ 2:34 / 4:08  🔊 65%  🔀 Shuffle: off
 
 # Volume
@@ -109,21 +109,6 @@ spotify_player search "query"
 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 |

package/skills/summarize.md

@@ -1,230 +1,73 @@
 ---
 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.
+description: Summarize long documents, articles, PDFs, web pages, emails, chat threads, meeting notes, or any large text. Use when asked to summarize, give a TL;DR, extract key points, or condense content.
 triggers: summarize, summary, tldr, tl;dr, condense, key points, brief, shorten, digest, recap, highlights, executive summary, abstract, overview
+metadata: {"daemora": {"emoji": "✂️"}}
 ---
 
-## When to Use
+## Summarization levels
 
-✅ 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 |
+| 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()
+| **TL;DR** | 1-3 sentences | Quick skim |
+| **Key Points** | 5-10 bullets | Decision making |
+| **Executive Summary** | 2-3 paragraphs | Briefing |
+| **Action Items** | Bullet list | After meetings |
 
-    if suffix in ('.txt', '.md', '.rst', '.log'):
-        content = p.read_text(encoding='utf-8', errors='ignore')
+## Getting content
 
-    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
+- URL → `webFetch(url)`
+- PDF → `pdftotext file.pdf -` or `pdfplumber`
+- `.docx` → `pandoc file.docx -t plain`
+- Long content → summarize in chunks, then summarize the summaries
 
-    elif suffix in ('.docx',):
-        import subprocess
-        result = subprocess.run(["pandoc", path, "-t", "plain"], capture_output=True, text=True)
-        content = result.stdout
+## Code / PR summary
 
-    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
-    )
+```bash
+git diff main..feature --stat
+git log main..feature --oneline
 ```
 
-## Summary Output Templates
-
-Use these structures when presenting summaries:
+## Output templates
 
-### TL;DR
+**TL;DR**
 ```
-**TL;DR:** [1-2 sentences capturing the absolute core message]
+**TL;DR:** [1-2 sentences capturing the core message]
 ```
 
-### Key Points
+**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]
+**Bottom line:** [One sentence conclusion]
 ```
 
-### Executive Summary
+**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]
+**What:** [one sentence]
+**Key findings:** [2-3 sentences]
+**Actions / decisions:** [bullets]
+**Next steps:** [bullets]
 ```
 
-### Meeting / Call Recap
+**Meeting recap**
 ```
-**Meeting Recap — [Date] — [Topic]**
+**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
+**Discussed:** [bullets]
+**Decisions:** [bullets]
+**Action items:** [Person → Task by Date]
 ```
 
-Structure code summary as:
+**Code changes**
 ```
 **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
+- Files: N changed, +X/-Y lines
+**What changed:** [per-component bullets]
+**Risk:** Low/Medium/High - [reason]
 ```