daemora 1.0.0

package/skills/obsidian.md

@@ -0,0 +1,207 @@
+---
+name: obsidian
+description: Read, create, edit, search, and manage notes in an Obsidian vault. Use when the user asks to create a note, find a note, update an Obsidian file, link notes, search their vault, or manage their knowledge base. Obsidian vaults are plain Markdown files — no special tools needed for basic operations.
+triggers: obsidian, note, vault, knowledge base, zettelkasten, markdown note, create note, find note, link note, obsidian search, obsidian plugin
+---
+
+## When to Use
+
+✅ Create notes, read notes, search vault, edit frontmatter, create links between notes, list all notes, tag management, daily notes
+
+❌ Obsidian UI automation (open a specific note visually) — use `obsidian://` URI scheme for that
+
+## Find the Vault Location
+
+```bash
+# Obsidian tracks vaults here on macOS:
+python3 -c "
+import json, pathlib
+config = pathlib.Path.home() / 'Library/Application Support/obsidian/obsidian.json'
+if config.exists():
+    data = json.loads(config.read_text())
+    for vault in data.get('vaults', {}).values():
+        status = '✅ (open)' if vault.get('open') else ''
+        print(f\"{vault['path']} {status}\")
+else:
+    print('Obsidian config not found — vault location unknown')
+"
+# Typical locations: ~/Documents/Obsidian/, ~/Notes/, ~/Documents/Notes/
+```
+
+## Read Notes
+
+```bash
+# Find all notes in vault
+find ~/Documents/Obsidian -name "*.md" | head -20
+
+# Search by content
+grep -r "search term" ~/Documents/Obsidian --include="*.md" -l
+
+# Search with context (2 lines around match)
+grep -r "search term" ~/Documents/Obsidian --include="*.md" -C 2
+
+# Find notes with a specific tag
+grep -r "^tags:.*tagname\|#tagname" ~/Documents/Obsidian --include="*.md" -l
+
+# Find notes created today (macOS)
+find ~/Documents/Obsidian -name "*.md" -newer $(date -v-1d +%Y-%m-%d 2>/dev/null || date -d "1 day ago" +%Y-%m-%d) 2>/dev/null
+```
+
+## Create a Note
+
+```python
+#!/usr/bin/env python3
+from pathlib import Path
+from datetime import datetime
+
+VAULT = Path.home() / "Documents/Obsidian"  # adjust to actual vault path
+
+def create_note(title: str, content: str, folder: str = "", tags: list = None):
+    """Create a note with YAML frontmatter."""
+    tags = tags or []
+    date = datetime.now().strftime("%Y-%m-%d")
+    time = datetime.now().strftime("%H:%M")
+
+    frontmatter = f"""---
+title: {title}
+date: {date}
+time: {time}
+tags: [{', '.join(tags)}]
+---
+
+"""
+    target_dir = VAULT / folder if folder else VAULT
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    # Sanitize filename
+    filename = title.replace("/", "-").replace(":", "-") + ".md"
+    filepath = target_dir / filename
+
+    # Don't overwrite — append timestamp if exists
+    if filepath.exists():
+        ts = datetime.now().strftime("%Y%m%d%H%M%S")
+        filepath = target_dir / f"{title} ({ts}).md"
+
+    filepath.write_text(frontmatter + content, encoding="utf-8")
+    print(f"Created: {filepath}")
+    return filepath
+
+# Example usage:
+create_note(
+    title="Meeting Notes — Q1 Review",
+    content="## Attendees\n- Alice\n- Bob\n\n## Key Points\n- ...",
+    folder="Meetings",
+    tags=["meeting", "q1-2026"]
+)
+```
+
+## Create Daily Note
+
+```python
+#!/usr/bin/env python3
+from pathlib import Path
+from datetime import datetime
+
+VAULT = Path.home() / "Documents/Obsidian"
+DAILY_FOLDER = VAULT / "Daily Notes"
+DAILY_FOLDER.mkdir(parents=True, exist_ok=True)
+
+today = datetime.now()
+filename = today.strftime("%Y-%m-%d") + ".md"
+filepath = DAILY_FOLDER / filename
+
+if not filepath.exists():
+    content = f"""---
+date: {today.strftime('%Y-%m-%d')}
+tags: [daily]
+---
+
+# {today.strftime('%A, %B %d, %Y')}
+
+## 🎯 Focus Today
+
+## 📝 Notes
+
+## ✅ Tasks
+- [ ]
+
+## 💭 Reflections
+
+"""
+    filepath.write_text(content)
+    print(f"Created daily note: {filepath}")
+else:
+    print(f"Daily note already exists: {filepath}")
+
+# Open it in Obsidian
+import subprocess
+subprocess.run(["open", f"obsidian://open?vault=Obsidian&file=Daily Notes/{today.strftime('%Y-%m-%d')}"])
+```
+
+## Edit Existing Note
+
+```python
+#!/usr/bin/env python3
+from pathlib import Path
+
+def append_to_note(note_path: str, content: str, section: str = None):
+    """Append content to a note, optionally under a specific section."""
+    path = Path(note_path)
+    existing = path.read_text(encoding="utf-8")
+
+    if section:
+        # Insert under the section heading
+        marker = f"## {section}"
+        if marker in existing:
+            idx = existing.index(marker) + len(marker)
+            # Find next line after heading
+            next_line = existing.find("\n", idx) + 1
+            updated = existing[:next_line] + "\n" + content + "\n" + existing[next_line:]
+        else:
+            updated = existing + f"\n## {section}\n\n{content}\n"
+    else:
+        updated = existing.rstrip() + f"\n\n{content}\n"
+
+    path.write_text(updated, encoding="utf-8")
+    print(f"Updated: {path}")
+
+# Example: append a task under ## ✅ Tasks
+append_to_note(
+    "/path/to/note.md",
+    "- [ ] New task item",
+    section="✅ Tasks"
+)
+```
+
+## Create Linked Notes (Wiki Links)
+
+Obsidian uses `[[Note Title]]` syntax for links. When creating a note that references others:
+
+```python
+# Create a note with backlinks
+content = """
+## Related Research
+
+See [[Market Analysis 2026]] for context.
+Building on [[Previous Meeting Notes]].
+
+## Summary
+...
+"""
+```
+
+## Open Note in Obsidian (macOS)
+
+```bash
+# Open specific note
+open "obsidian://open?vault=VAULT_NAME&file=PATH/TO/NOTE"
+
+# Open search in Obsidian
+open "obsidian://search?vault=VAULT_NAME&query=search+term"
+```
+
+## Error Handling
+
+- **Vault not found**: read `~/Library/Application Support/obsidian/obsidian.json` to locate vaults; ask user to confirm vault path if multiple exist
+- **File already exists**: always check before writing; either append content or create new file with timestamp suffix
+- **Encoding issues**: always use `encoding="utf-8"` when reading/writing `.md` files

package/skills/pdf.md

@@ -0,0 +1,211 @@
+---
+name: pdf
+description: Create, read, extract text from, merge, split, rotate, compress, and manipulate PDF files. Use when the user asks to create a PDF report/document, extract text from a PDF, merge PDFs, convert to PDF, or do any PDF operation. Works on macOS and Linux without paid tools.
+triggers: pdf, create pdf, read pdf, extract pdf, merge pdf, split pdf, convert to pdf, pdf report, pdf document, compress pdf, rotate pdf
+---
+
+## When to Use
+
+✅ Create PDF reports/documents, extract text from PDFs, merge multiple PDFs, split pages, rotate, compress, convert HTML/Markdown to PDF
+
+❌ PDF form filling with complex logic → use PyPDF2 + pdfrw; PDF digital signatures → use specialized tools
+
+## Method 1: Create PDF from HTML (best quality, macOS)
+
+```bash
+# Install wkhtmltopdf (one-time)
+brew install wkhtmltopdf
+
+# Create HTML file, then convert
+cat > /tmp/report.html << 'EOF'
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="UTF-8">
+<style>
+  body { font-family: -apple-system, Arial, sans-serif; margin: 40px; color: #222; }
+  h1 { color: #1a1a2e; border-bottom: 2px solid #eee; padding-bottom: 10px; }
+  h2 { color: #444; margin-top: 30px; }
+  table { border-collapse: collapse; width: 100%; margin: 16px 0; }
+  th { background: #f0f4ff; padding: 10px; text-align: left; border: 1px solid #ddd; }
+  td { padding: 8px 10px; border: 1px solid #eee; }
+  .highlight { background: #fffbea; padding: 12px; border-left: 4px solid #f0c040; }
+</style>
+</head>
+<body>
+  <h1>Report Title</h1>
+  <p>Content here</p>
+</body>
+</html>
+EOF
+
+wkhtmltopdf \
+  --page-size A4 \
+  --margin-top 20mm --margin-bottom 20mm \
+  --margin-left 15mm --margin-right 15mm \
+  --encoding UTF-8 \
+  --footer-center "[page] / [topage]" \
+  --footer-font-size 9 \
+  /tmp/report.html /tmp/report.pdf
+
+echo "Created: /tmp/report.pdf"
+open /tmp/report.pdf   # preview on macOS
+```
+
+## Method 2: Create PDF with Python (cross-platform, no external binaries)
+
+```python
+#!/usr/bin/env python3
+"""Create a PDF without any system binaries — uses reportlab."""
+# Install once: pip install reportlab
+from reportlab.lib.pagesizes import A4
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.units import mm
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
+from reportlab.lib import colors
+
+output_path = "/tmp/report.pdf"
+doc = SimpleDocTemplate(output_path, pagesize=A4,
+    leftMargin=20*mm, rightMargin=20*mm,
+    topMargin=20*mm, bottomMargin=20*mm)
+
+styles = getSampleStyleSheet()
+story = []
+
+# Title
+title_style = ParagraphStyle('Title', parent=styles['Title'],
+    fontSize=24, spaceAfter=12)
+story.append(Paragraph("Report Title", title_style))
+story.append(Spacer(1, 8*mm))
+
+# Body text
+story.append(Paragraph("Your content here. Supports <b>bold</b>, <i>italic</i>, and links.", styles['BodyText']))
+story.append(Spacer(1, 6*mm))
+
+# Table
+data = [['Column A', 'Column B', 'Column C'],
+        ['Row 1',    'Value',    '$100'],
+        ['Row 2',    'Value',    '$200']]
+table = Table(data, colWidths=[60*mm, 60*mm, 40*mm])
+table.setStyle(TableStyle([
+    ('BACKGROUND', (0,0), (-1,0), colors.HexColor('#e8eaf6')),
+    ('FONTNAME',   (0,0), (-1,0), 'Helvetica-Bold'),
+    ('GRID',       (0,0), (-1,-1), 0.5, colors.HexColor('#cccccc')),
+    ('ROWBACKGROUNDS', (0,1), (-1,-1), [colors.white, colors.HexColor('#f8f9ff')]),
+    ('PADDING',    (0,0), (-1,-1), 8),
+]))
+story.append(table)
+
+doc.build(story)
+print(f"Created: {output_path}")
+```
+
+## Read / Extract Text from PDF
+
+```python
+#!/usr/bin/env python3
+# pip install pdfplumber  (better than pypdf2 for text extraction)
+import pdfplumber, sys
+
+pdf_path = sys.argv[1] if len(sys.argv) > 1 else "/path/to/file.pdf"
+
+with pdfplumber.open(pdf_path) as pdf:
+    print(f"Pages: {len(pdf.pages)}")
+    for i, page in enumerate(pdf.pages, 1):
+        text = page.extract_text()
+        if text:
+            print(f"\n--- Page {i} ---\n{text}")
+
+        # Also extract tables
+        tables = page.extract_tables()
+        for t in tables:
+            print(f"\n[Table on page {i}]")
+            for row in t:
+                print(" | ".join(str(c or '') for c in row))
+```
+
+## Merge PDFs
+
+```python
+#!/usr/bin/env python3
+# pip install pypdf
+from pypdf import PdfWriter, PdfReader
+import sys
+
+output = "/tmp/merged.pdf"
+writer = PdfWriter()
+
+for path in sys.argv[1:]:
+    reader = PdfReader(path)
+    for page in reader.pages:
+        writer.add_page(page)
+
+with open(output, "wb") as f:
+    writer.write(f)
+print(f"Merged {len(sys.argv)-1} PDFs → {output}")
+```
+
+## Split PDF (extract page range)
+
+```python
+#!/usr/bin/env python3
+# pip install pypdf
+from pypdf import PdfWriter, PdfReader
+
+input_pdf = "/path/to/input.pdf"
+output_pdf = "/tmp/extracted_pages.pdf"
+start_page = 0   # 0-indexed
+end_page   = 5   # exclusive
+
+reader = PdfReader(input_pdf)
+writer = PdfWriter()
+for i in range(start_page, min(end_page, len(reader.pages))):
+    writer.add_page(reader.pages[i])
+with open(output_pdf, "wb") as f:
+    writer.write(f)
+print(f"Extracted pages {start_page+1}-{end_page} → {output_pdf}")
+```
+
+## Compress PDF (macOS, no install)
+
+```bash
+# Uses macOS built-in Quartz filter
+"/System/Library/Printers/Libraries/quartzfilter" \
+  /System/Library/Filters/Reduce\ File\ Size.qfilter \
+  /path/to/input.pdf /tmp/compressed.pdf
+
+# Or via Python with ghostscript
+gs -sDEVICE=pdfwrite -dCompatibilityLevel=1.5 \
+   -dPDFSETTINGS=/ebook \
+   -dNOPAUSE -dQUIET -dBATCH \
+   -sOutputFile=/tmp/compressed.pdf /path/to/input.pdf
+# PDFSET options: /screen (72dpi) /ebook (150dpi) /printer (300dpi) /prepress (300dpi HQ)
+```
+
+## Convert Markdown → PDF
+
+```bash
+# pip install md-to-pdf  OR  brew install pandoc
+# With pandoc (best quality):
+pandoc input.md -o output.pdf \
+  --pdf-engine=wkhtmltopdf \
+  -V geometry:margin=25mm \
+  -V fontsize=11pt
+
+# Quick and dirty with Python:
+pip install markdown weasyprint
+python3 -c "
+import markdown, weasyprint, pathlib
+md = pathlib.Path('input.md').read_text()
+html = markdown.markdown(md, extensions=['tables','fenced_code'])
+weasyprint.HTML(string=f'<html><body style=\"font-family:sans-serif;margin:40px\">{html}</body></html>').write_pdf('output.pdf')
+print('output.pdf')
+"
+```
+
+## After Creating PDF
+
+1. Report the output path: "PDF saved to `/tmp/report.pdf`"
+2. On macOS, offer to open it: `executeCommand("open /tmp/report.pdf")`
+3. If the user wants to send it, use `sendFile("/tmp/report.pdf", channel, sessionId)`
+4. For large reports: mention page count and file size

package/skills/research.md

@@ -0,0 +1,13 @@
+---
+name: research
+description: Use when researching topics, gathering information, or answering questions
+triggers: research, search, find, look up, what is, how does, explain, learn, investigate, compare
+---
+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.

package/skills/skill-creator.md

@@ -0,0 +1,142 @@
+---
+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.
+triggers: create skill, new skill, add skill, make skill, package skill, teach agent, skill creator, write 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.
+
+## Skill File 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.
+triggers: keyword1, keyword2, phrase, another phrase
+---
+
+## When to Use
+
+✅ Specific cases where this skill applies
+❌ Cases where it does NOT apply (prevents false triggers)
+
+## Core Instructions
+
+[Domain-specific knowledge, commands, workflows]
+
+## Examples / Commands
+
+[Concrete, working examples with real commands the agent can copy-paste]
+
+## Error Handling
+
+[What to do when things go wrong]
+```
+
+## 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
+```
+
+### Step 4 — Reload skills
+
+After creating a skill:
+
+```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...
+```
+
+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
+
+## Do NOT Create Skills For
+
+- 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)