daemora 1.0.0

package/skills/healthcheck.md

@@ -0,0 +1,225 @@
+---
+name: healthcheck
+description: Monitor system health, check disk usage, CPU load, memory, running processes, network connectivity, and service status. Use when the user asks about system health, disk space, memory usage, CPU usage, running processes, server status, or whether a service is running. Works on macOS and Linux.
+triggers: health check, disk space, memory usage, CPU usage, system status, process running, server health, is running, disk full, system monitor, uptime, load average
+---
+
+## When to Use
+
+✅ Check disk space, memory, CPU, running processes, network, service uptime, port availability, web endpoint health, log tails
+
+❌ Deep profiling or performance tracing — use dedicated profilers (Instruments, perf, etc.)
+
+## Full System Health Report
+
+```bash
+python3 << 'EOF'
+import subprocess, platform, os
+from datetime import datetime
+
+def run(cmd):
+    r = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+    return r.stdout.strip()
+
+print(f"🖥  System Health Report — {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+print(f"{'─'*50}")
+
+# OS + Uptime
+print(f"OS:      {platform.system()} {platform.mac_ver()[0] or platform.release()}")
+print(f"Uptime:  {run('uptime | sed s/.*up/up/')}")
+
+# CPU
+if platform.system() == "Darwin":
+    load = os.getloadavg()
+    cpu_count = int(run("sysctl -n hw.ncpu"))
+    print(f"CPU:     load {load[0]:.2f} / {load[1]:.2f} / {load[2]:.2f}  ({cpu_count} cores)")
+else:
+    print(f"CPU:     {run('top -bn1 | grep Cpu | head -1')}")
+
+# Memory
+if platform.system() == "Darwin":
+    mem = run("vm_stat")
+    page_size = 4096
+    lines = {l.split(':')[0].strip(): int(l.split(':')[1].strip().rstrip('.'))
+             for l in mem.split('\n') if ':' in l}
+    free = (lines.get('Pages free', 0) + lines.get('Pages speculative', 0)) * page_size / 1024**3
+    active = lines.get('Pages active', 0) * page_size / 1024**3
+    wired = lines.get('Pages wired down', 0) * page_size / 1024**3
+    total = float(run("sysctl -n hw.memsize")) / 1024**3
+    used = total - free
+    print(f"Memory:  {used:.1f}GB used / {total:.1f}GB total ({free:.1f}GB free)")
+else:
+    print(f"Memory:  {run('free -h | grep Mem')}")
+
+# Disk
+import shutil
+disks = ['/'] + (['/Volumes/' + d for d in os.listdir('/Volumes')] if os.path.exists('/Volumes') else [])
+print("\nDisk Usage:")
+for disk in disks:
+    try:
+        total, used, free = shutil.disk_usage(disk)
+        pct = used / total * 100
+        bar = '█' * int(pct/5) + '░' * (20 - int(pct/5))
+        status = "⚠️" if pct > 85 else "✅"
+        print(f"  {status} {disk:<20} {bar} {pct:.0f}%  ({free/1024**3:.0f}GB free)")
+    except:
+        pass
+EOF
+```
+
+## Disk Space Check
+
+```bash
+# Quick disk check
+df -h | grep -E "^/dev|Filesystem"
+
+# Find largest directories (top 10)
+du -sh /* 2>/dev/null | sort -rh | head -10
+
+# Find large files (>100MB) in a directory
+find ~/Downloads -size +100M -exec ls -lh {} \; 2>/dev/null | sort -k5 -rh | head -20
+
+# Check inode usage (different from disk space — can be "full" with space remaining)
+df -i /
+```
+
+## Memory Usage
+
+```bash
+# macOS
+vm_stat && top -l 1 -n 0 | grep -E "PhysMem|CPU"
+
+# Top memory-consuming processes
+ps aux --sort=-%mem 2>/dev/null | head -10 || \
+ps aux | sort -k4 -rn | head -10
+```
+
+## CPU Usage
+
+```bash
+# Top CPU processes
+ps aux --sort=-%cpu 2>/dev/null | head -10 || \
+ps aux | sort -k3 -rn | head -10
+
+# macOS: CPU usage over 5 seconds
+top -l 2 -n 0 -stats cpu | tail -5
+```
+
+## Check if a Process is Running
+
+```python
+#!/usr/bin/env python3
+import subprocess, sys
+
+def is_running(process_name: str) -> tuple[bool, list[str]]:
+    """Check if a process is running. Returns (running, [pid lines])."""
+    result = subprocess.run(
+        ["pgrep", "-fl", process_name],
+        capture_output=True, text=True
+    )
+    lines = [l for l in result.stdout.strip().split('\n') if l and process_name.lower() in l.lower()]
+    return len(lines) > 0, lines
+
+# Check common services
+services = ["nginx", "postgres", "redis-server", "node", "python3", "docker"]
+for svc in services:
+    running, pids = is_running(svc)
+    icon = "✅" if running else "❌"
+    info = f"  PIDs: {', '.join(p.split()[0] for p in pids[:3])}" if running else ""
+    print(f"{icon} {svc:<20}{info}")
+```
+
+## Check Port Availability
+
+```bash
+# Check if a port is in use
+PORT=3000
+lsof -i :$PORT 2>/dev/null | grep LISTEN || echo "Port $PORT is free"
+
+# List all listening ports
+lsof -nP -iTCP -sTCP:LISTEN 2>/dev/null | awk 'NR>1 {print $1, $9}' | sort -u
+
+# Check if a service is actually responding
+curl -s -o /dev/null -w "%{http_code}" http://localhost:3000/health
+```
+
+## HTTP Endpoint Health Check
+
+```python
+#!/usr/bin/env python3
+import urllib.request, urllib.error, time, json
+
+def check_endpoint(url: str, timeout: int = 5) -> dict:
+    """Check if an HTTP endpoint is healthy."""
+    start = time.time()
+    try:
+        req = urllib.request.Request(url)
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            latency = (time.time() - start) * 1000
+            return {
+                "url": url,
+                "status": resp.status,
+                "latency_ms": round(latency, 1),
+                "healthy": 200 <= resp.status < 300
+            }
+    except urllib.error.HTTPError as e:
+        return {"url": url, "status": e.code, "healthy": False, "error": str(e)}
+    except Exception as e:
+        return {"url": url, "status": 0, "healthy": False, "error": str(e)}
+
+# Check multiple endpoints
+endpoints = [
+    "http://localhost:3000/health",
+    "http://localhost:8081/health",
+    "https://api.example.com/ping",
+]
+
+print("🔍 Endpoint Health Check")
+print(f"{'─'*60}")
+for ep in endpoints:
+    result = check_endpoint(ep)
+    icon = "✅" if result["healthy"] else "❌"
+    latency = f"{result['latency_ms']}ms" if result["healthy"] else result.get("error", "unreachable")
+    print(f"{icon} {result['status']}  {latency:<15}  {ep}")
+```
+
+## Check Recent Errors in Logs
+
+```bash
+# System log (macOS)
+log show --last 1h --predicate 'messageType == 16 or messageType == 17' \
+  --style syslog 2>/dev/null | tail -20
+
+# Application log tail
+tail -100 ~/Library/Logs/your-app/app.log 2>/dev/null | grep -iE "error|warn|fatal" | tail -20
+
+# Daemora agent logs
+tail -50 data/audit/*.jsonl 2>/dev/null | python3 -c "
+import sys, json
+for line in sys.stdin:
+    try:
+        e = json.loads(line)
+        if e.get('type') in ['error', 'warn']:
+            print(f\"{e['timestamp']} [{e['type']}] {e.get('message', '')}\")
+    except: pass
+"
+```
+
+## Response Format
+
+Present health check results as a clean status dashboard:
+
+```
+🖥  System Health — MacBook Pro
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+✅ Uptime:   up 3 days, 4:22
+✅ CPU:      load 0.8 / 1.2 / 1.5  (8 cores)
+✅ Memory:   6.2GB used / 16GB total  (9.8GB free)
+⚠️ Disk /:   ████████████████░░░░ 82%  (38GB free)  ← getting full
+✅ Disk /Volumes/Data: ████░░░░░░░░░░░░░░░░ 22%  (780GB free)
+
+Services:
+✅ node       (PID 4821)
+✅ postgres   (PID 1203)
+❌ redis      not running
+```

package/skills/image-gen.md

@@ -0,0 +1,147 @@
+---
+name: image-gen
+description: Generate images using OpenAI's image models (gpt-image-1, DALL-E 3, DALL-E 2). Use when the user asks to create, generate, draw, or illustrate an image, photo, logo, icon, illustration, or visual. Requires OPENAI_API_KEY.
+triggers: generate image, create image, draw, illustrate, make a picture, logo, icon, artwork, visual, dall-e, image generation, render
+---
+
+## When to Use
+
+✅ Creating images from text descriptions, generating logos/icons, batch image sets, product mockups, illustration requests, visual content
+
+❌ Editing existing images (use gpt-image-1 with input image), video generation, real-time/live images
+
+## Models
+
+| Model | Best For | Max Count | Quality Options |
+|-------|---------|-----------|----------------|
+| `gpt-image-1` | Highest quality, follows prompts best | 10/call | `high`, `medium`, `low` |
+| `dall-e-3` | Artistic, stylized | 1/call | `hd`, `standard` |
+| `dall-e-2` | Fast, cheap drafts | 10/call | `standard` |
+
+Default: `gpt-image-1` at `high` quality.
+
+## Single Image (Python)
+
+```python
+#!/usr/bin/env python3
+import os, base64, json, urllib.request, urllib.parse
+from datetime import datetime
+from pathlib import Path
+
+api_key = os.environ["OPENAI_API_KEY"]
+prompt  = "A sleek futuristic dashboard UI in dark mode, neon blue accents, clean typography"
+model   = "gpt-image-1"   # or "dall-e-3", "dall-e-2"
+size    = "1024x1024"     # gpt-image-1: 1024x1024, 1536x1024 (landscape), 1024x1536 (portrait)
+quality = "high"          # gpt-image-1: high/medium/low | dall-e-3: hd/standard
+
+payload = json.dumps({
+    "model": model, "prompt": prompt,
+    "n": 1, "size": size, "quality": quality,
+    "response_format": "b64_json"
+}).encode()
+
+req = urllib.request.Request(
+    "https://api.openai.com/v1/images/generations",
+    data=payload,
+    headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+)
+resp = json.loads(urllib.request.urlopen(req).read())
+
+out_dir = Path("/tmp/daemora-images")
+out_dir.mkdir(exist_ok=True)
+ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+out_file = out_dir / f"image_{ts}.png"
+out_file.write_bytes(base64.b64decode(resp["data"][0]["b64_json"]))
+print(f"Saved: {out_file}")
+```
+
+## Batch Generation
+
+```python
+#!/usr/bin/env python3
+"""Generate multiple images with varied prompts and save to a gallery."""
+import os, base64, json, urllib.request, urllib.parse
+from pathlib import Path
+from datetime import datetime
+
+API_KEY = os.environ["OPENAI_API_KEY"]
+OUT_DIR = Path("/tmp/daemora-images") / datetime.now().strftime("%Y%m%d_%H%M%S")
+OUT_DIR.mkdir(parents=True, exist_ok=True)
+
+PROMPTS = [
+    "prompt 1 here",
+    "prompt 2 here",
+]
+
+def generate(prompt, model="gpt-image-1", size="1024x1024", quality="high"):
+    payload = json.dumps({
+        "model": model, "prompt": prompt,
+        "n": 1, "size": size, "quality": quality,
+        "response_format": "b64_json"
+    }).encode()
+    req = urllib.request.Request(
+        "https://api.openai.com/v1/images/generations",
+        data=payload,
+        headers={"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}
+    )
+    return json.loads(urllib.request.urlopen(req).read())["data"][0]["b64_json"]
+
+saved = []
+for i, prompt in enumerate(PROMPTS):
+    print(f"Generating {i+1}/{len(PROMPTS)}: {prompt[:50]}...")
+    try:
+        img_b64 = generate(prompt)
+        path = OUT_DIR / f"image_{i+1:02d}.png"
+        path.write_bytes(base64.b64decode(img_b64))
+        saved.append((path, prompt))
+        print(f"  ✅ Saved: {path}")
+    except Exception as e:
+        print(f"  ❌ Failed: {e}")
+
+# Write HTML gallery
+html = f"""<!DOCTYPE html><html><head><title>Generated Images</title>
+<style>body{{background:#111;color:#eee;font-family:sans-serif;padding:20px}}
+.grid{{display:grid;grid-template-columns:repeat(auto-fill,minmax(300px,1fr));gap:16px}}
+img{{width:100%;border-radius:8px}} p{{font-size:12px;opacity:.7;margin:4px 0 12px}}</style></head>
+<body><h2>Daemora Image Generation — {len(saved)} images</h2><div class="grid">
+"""
+for path, prompt in saved:
+    html += f'<div><img src="{path.name}" alt=""><p>{prompt}</p></div>\n'
+html += "</div></body></html>"
+(OUT_DIR / "index.html").write_text(html)
+print(f"\nGallery: {OUT_DIR / 'index.html'}")
+print(f"Open: open '{OUT_DIR / 'index.html'}'")
+```
+
+## Size Options by Model
+
+```
+gpt-image-1:  1024x1024 (square) | 1536x1024 (landscape) | 1024x1536 (portrait) | auto
+dall-e-3:     1024x1024 | 1792x1024 (wide) | 1024x1792 (tall)
+dall-e-2:     256x256 | 512x512 | 1024x1024
+```
+
+## Prompt Writing Tips
+
+- **Be specific**: "A minimalist logo for a fintech startup, dark blue on white, geometric sans-serif font" beats "a logo"
+- **Specify style**: photorealistic / watercolor / flat illustration / 3D render / oil painting
+- **Specify lighting**: soft studio lighting / dramatic shadows / golden hour / neon
+- **Specify composition**: bird's eye view / close-up / wide angle / portrait
+- **Negative guidance**: add "no text, no watermarks" if needed
+
+## After Generation
+
+Always:
+1. Save images to `/tmp/daemora-images/` or a user-specified path
+2. Report the file path(s) in the response
+3. For multiple images, open the HTML gallery: `executeCommand("open /tmp/daemora-images/*/index.html")`
+4. If the user wants to send the image, use `sendFile(path, channel, sessionId)`
+
+## Error Handling
+
+| Error | Fix |
+|-------|-----|
+| 400 content policy | Rephrase prompt, remove potentially flagged terms |
+| 401 unauthorized | Check `OPENAI_API_KEY` is set and valid |
+| 429 rate limit | Wait 10s, retry with `n=1` |
+| 503 unavailable | Retry after 30s; fall back to dall-e-3 |

package/skills/model-usage.md

@@ -0,0 +1,182 @@
+---
+name: model-usage
+description: Track and report AI model API usage, costs, token counts, and spending across OpenAI, Anthropic, and Google. Use when the user asks how much they've spent, their API usage, token counts, cost breakdown, daily/monthly costs, or wants to optimize AI spending. Also check Daemora's built-in cost tracking.
+triggers: model usage, api cost, token usage, spending, how much spent, cost breakdown, openai usage, anthropic usage, api usage, cost report, ai spending, daily cost, monthly cost
+---
+
+## When to Use
+
+✅ Check today's/this month's API costs, per-model breakdown, token counts, cost trends, optimization suggestions, Daemora internal cost report
+
+❌ Real-time streaming token counts — use the Daemora `/costs/today` endpoint for live data
+
+## Daemora Built-in Cost Tracking
+
+```bash
+# Today's costs (all models, all tasks)
+curl -s http://localhost:8081/costs/today | python3 -c "
+import sys, json
+d = json.load(sys.stdin)
+print(f\"Today's spend: \${d.get('totalCost', 0):.4f}\")
+print(f\"Tasks: {d.get('taskCount', 0)}\")
+print(f\"Tokens: {d.get('totalTokens', 0):,} ({d.get('inputTokens',0):,} in / {d.get('outputTokens',0):,} out)\")
+if 'byModel' in d:
+    print('\\nBy model:')
+    for model, cost in sorted(d['byModel'].items(), key=lambda x: -x[1]):
+        print(f\"  {model:<40} \${cost:.4f}\")
+"
+```
+
+## Parse Daemora Cost Log Directly
+
+```python
+#!/usr/bin/env python3
+"""Parse Daemora's JSONL cost log for detailed analysis."""
+import json, os
+from pathlib import Path
+from datetime import datetime, date, timedelta
+from collections import defaultdict
+
+COST_DIR = Path("data/costs")  # adjust if different
+
+def load_cost_log(days: int = 30) -> list[dict]:
+    """Load cost entries from the last N days."""
+    entries = []
+    cutoff = date.today() - timedelta(days=days)
+    for log_file in sorted(COST_DIR.glob("*.jsonl")):
+        try:
+            file_date = date.fromisoformat(log_file.stem)
+            if file_date < cutoff:
+                continue
+        except:
+            pass
+        for line in log_file.read_text().splitlines():
+            if line.strip():
+                try:
+                    entries.append(json.loads(line))
+                except:
+                    pass
+    return entries
+
+def cost_report(days: int = 7):
+    entries = load_cost_log(days)
+    if not entries:
+        print("No cost data found")
+        return
+
+    by_day     = defaultdict(float)
+    by_model   = defaultdict(float)
+    by_tenant  = defaultdict(float)
+    total_cost = 0
+    total_in   = 0
+    total_out  = 0
+
+    for e in entries:
+        cost   = e.get("estimatedCost", 0) or 0
+        ts     = e.get("timestamp", "")[:10]
+        model  = e.get("modelId", "unknown")
+        tenant = e.get("tenantId", "default")
+
+        total_cost       += cost
+        total_in         += e.get("inputTokens", 0) or 0
+        total_out        += e.get("outputTokens", 0) or 0
+        by_day[ts]       += cost
+        by_model[model]  += cost
+        by_tenant[tenant] += cost
+
+    print(f"📊 Cost Report — Last {days} days")
+    print(f"{'═'*50}")
+    print(f"Total spend:  ${total_cost:.4f}")
+    print(f"Total tokens: {total_in+total_out:,} ({total_in:,} in / {total_out:,} out)")
+    print(f"Tasks:        {len(entries)}")
+
+    print(f"\n📅 Daily breakdown:")
+    for day in sorted(by_day.keys(), reverse=True)[:days]:
+        bar = '█' * int(by_day[day] / max(by_day.values()) * 20) if by_day else ''
+        print(f"  {day}  {bar:<20} ${by_day[day]:.4f}")
+
+    print(f"\n🤖 By model:")
+    for model, cost in sorted(by_model.items(), key=lambda x: -x[1]):
+        pct = cost / total_cost * 100 if total_cost else 0
+        print(f"  {model:<40} ${cost:.4f}  ({pct:.0f}%)")
+
+    if len(by_tenant) > 1:
+        print(f"\n👤 By tenant:")
+        for tenant, cost in sorted(by_tenant.items(), key=lambda x: -x[1]):
+            print(f"  {tenant:<30} ${cost:.4f}")
+
+cost_report(days=7)
+```
+
+## OpenAI Usage via API
+
+```python
+#!/usr/bin/env python3
+"""Check OpenAI API usage and costs for current month."""
+import os, json, urllib.request
+from datetime import date
+
+API_KEY = os.environ.get("OPENAI_API_KEY", "")
+if not API_KEY:
+    print("OPENAI_API_KEY not set")
+    exit(1)
+
+# OpenAI usage endpoint (requires org-level key for detailed breakdown)
+today = date.today()
+start = f"{today.year}-{today.month:02d}-01"
+end   = today.isoformat()
+
+req = urllib.request.Request(
+    f"https://api.openai.com/v1/usage?date={today.isoformat()}",
+    headers={"Authorization": f"Bearer {API_KEY}"}
+)
+try:
+    resp = json.loads(urllib.request.urlopen(req).read())
+    # Parse usage data
+    data = resp.get("data", [])
+    total_requests = sum(d.get("n_requests", 0) for d in data)
+    total_tokens = sum(d.get("n_context_tokens_total", 0) + d.get("n_generated_tokens_total", 0) for d in data)
+    print(f"OpenAI Usage — {today}")
+    print(f"Requests: {total_requests:,}")
+    print(f"Tokens:   {total_tokens:,}")
+    print("\nNote: Cost data available in OpenAI dashboard → Usage")
+except Exception as e:
+    print(f"Could not fetch OpenAI usage: {e}")
+    print("Check usage at: https://platform.openai.com/usage")
+```
+
+## Cost Optimization Suggestions
+
+When a user asks about costs, always include optimization tips:
+
+```
+💡 Cost Optimization Tips:
+
+1. **Model routing** — Use CODE_MODEL=anthropic:claude-sonnet-4-6 for code,
+   RESEARCH_MODEL=google:gemini-2.0-flash for research (fast + cheap).
+   Simple tasks don't need the most expensive model.
+
+2. **Sub-agent profiles** — spawnAgent with profile="researcher" uses the
+   cheaper RESEARCH_MODEL, not the default expensive model.
+
+3. **Per-tenant limits** — Set maxDailyCost per user to prevent runaway spending:
+   `daemora tenant set <id> maxDailyCost 1.00`
+
+4. **Global daily cap** — Set MAX_DAILY_COST=5.00 in .env
+
+5. **Task cost cap** — Set MAX_COST_PER_TASK=0.25 to kill expensive tasks early
+
+6. **Check cost/task** — Use /costs/today to see which tasks are expensive,
+   then route those to cheaper models
+```
+
+## Cost Estimates (approximate, 2026 pricing)
+
+| Model | Input (per 1M) | Output (per 1M) | Good for |
+|-------|---------------|-----------------|---------|
+| gpt-4.1-mini | $0.15 | $0.60 | Most tasks |
+| gpt-4.1 | $2.00 | $8.00 | Complex reasoning |
+| claude-sonnet-4-6 | $3.00 | $15.00 | Code, analysis |
+| claude-opus-4-6 | $15.00 | $75.00 | Hard problems only |
+| gemini-2.0-flash | $0.075 | $0.30 | Research, summaries |
+| gemini-2.5-pro | $1.25 | $10.00 | Long context |