clamper-ai 1.1.6

package/skills/clawkit-sync/SKILL.md

@@ -0,0 +1,160 @@
+---
+name: clamper-sync
+description: "Sync agent state with Clamper cloud dashboard. Pushes model, cron jobs, connected accounts, activity, and preferences to the Clamper API. Pulls pending changes from dashboard."
+---
+
+# Clamper Sync Skill
+
+Synchronizes your OpenClaw agent state with the Clamper cloud dashboard at https://clamper.tech. This enables remote monitoring and control of your agent from any browser.
+
+## Prerequisites
+
+- A `skills/.clamper/config.json` file with your API key:
+  ```json
+  { "apiKey": "ck_...", "dashboardUrl": "https://clamper.tech" }
+  ```
+- If this file doesn't exist, skip sync silently.
+
+## Sync Protocol
+
+Run this on every heartbeat (or at least every 15 minutes). If any step fails, log the error and continue — never crash or block the heartbeat.
+
+### Step 1: Read Config
+
+```bash
+cat skills/.clamper/config.json
+```
+
+Extract the `apiKey` value. If the file is missing or has no `apiKey`, stop here silently.
+
+### Step 2: Gather State
+
+Collect the following data. Each piece is optional — if you can't read something, use `null`.
+
+#### 2a. Current Model
+
+Use the `session_status` tool (no parameters). Extract the `model` field from the response.
+
+#### 2b. Connected Accounts
+
+Read `TOOLS.md` and scan for sections that contain API keys, tokens, or credentials. For each one, extract:
+- `service`: The section heading (e.g., "Google Workspace", "Stripe", "Twitter/X API")
+- `maskedKey`: Take the credential value, show first 4 and last 4 characters, mask the rest with `***` (e.g., `sk_t***1OkA`)
+- `type`: "api_key", "token", "oauth", or "bearer"
+
+Example parsing logic:
+- Look for lines matching patterns like `**API Key:**`, `**Token:**`, `**Bearer Token:**`, `**Secret Key:**`
+- Extract the value after the `:`
+- Mask it: `value.slice(0, 4) + '***' + value.slice(-4)`
+
+#### 2c. Cron Jobs
+
+Use the cron tool with `action: "list"`. Collect the array of cron jobs (id, schedule, description).
+
+#### 2d. Recent Activity
+
+Read today's daily note: `memory/daily/YYYY-MM-DD.md` (use today's date). Extract the last 10 bullet points or log entries. If the file doesn't exist, use `[]`.
+
+#### 2e. Preferences
+
+Read `skills/.clamper/config.json` fully. Include any preferences beyond `apiKey` (e.g., `theme`, `notifications`, `syncInterval`).
+
+#### 2f. Memory Stats
+
+Run these shell commands:
+```bash
+# Count daily note files
+ls memory/daily/*.md 2>/dev/null | wc -l
+
+# Count knowledge files  
+ls memory/knowledge/*.md 2>/dev/null | wc -l
+
+# MEMORY.md size in bytes
+wc -c < MEMORY.md 2>/dev/null || echo 0
+```
+
+#### 2g. Installed Skills
+
+```bash
+ls -d skills/*/ 2>/dev/null | sed 's|skills/||;s|/||'
+```
+
+List directory names under `skills/`, excluding hidden dirs like `.clamper` and `.clawhub`.
+
+### Step 3: Push State to API
+
+Execute this curl command (via shell exec):
+
+```bash
+curl -s -X POST https://clamper-api.vercel.app/api/dashboard/sync \
+  -H "Content-Type: application/json" \
+  -d '{
+    "apiKey": "<API_KEY_FROM_CONFIG>",
+    "state": {
+      "model": "<current model string>",
+      "accounts": [
+        { "service": "Service Name", "maskedKey": "sk_t***1OkA", "type": "api_key" }
+      ],
+      "cronJobs": [ { "id": "...", "schedule": "...", "description": "..." } ],
+      "recentActivity": ["line 1", "line 2"],
+      "preferences": { "theme": "dark" },
+      "memoryStats": {
+        "dailyNotes": 42,
+        "knowledgeFiles": 7,
+        "memoryMdBytes": 15360
+      },
+      "installedSkills": ["weather", "productivity", "csv-pipeline"],
+      "syncedAt": "<ISO 8601 timestamp>"
+    }
+  }'
+```
+
+Replace all `<...>` placeholders with actual gathered values. The `syncedAt` field should be the current time in ISO 8601 format.
+
+### Step 4: Process Pending Changes
+
+The sync API response is JSON with this structure:
+```json
+{
+  "ok": true,
+  "pendingChanges": [
+    { "id": "ch_123", "type": "model_switch", "data": { "model": "anthropic/claude-sonnet-4-20250514" } },
+    { "id": "ch_456", "type": "connect_account", "data": { "service": "OpenAI", "section": "## OpenAI\n- **API Key:** sk-..." } },
+    { "id": "ch_789", "type": "disconnect_account", "data": { "service": "Stripe" } },
+    { "id": "ch_012", "type": "preferences", "data": { "theme": "light", "notifications": true } }
+  ]
+}
+```
+
+Process each pending change:
+
+#### `model_switch`
+Use `session_status` tool with the `model` parameter set to `data.model` to switch the active model.
+
+#### `connect_account`
+Append `data.section` to the end of `TOOLS.md` (before the final `---` line if one exists, otherwise at the end). The section content is pre-formatted markdown.
+
+#### `disconnect_account`
+Find the section in `TOOLS.md` whose heading matches `data.service` (case-insensitive). Remove that entire section (from `## Service Name` to the next `##` heading or end of file).
+
+#### `preferences`
+Read `skills/.clamper/config.json`, merge `data` into the existing object (overwriting matching keys), and write it back.
+
+### Step 5: Log Result
+
+Append a line to today's `memory/daily/YYYY-MM-DD.md`:
+
+```markdown
+- **[Clamper Sync]** Synced at HH:MM. Pushed state (N accounts, M skills, K cron jobs). Processed X pending changes.
+```
+
+## Error Handling
+
+- If `skills/.clamper/config.json` is missing → skip sync entirely, no error
+- If the API returns non-200 or curl fails → log "Clamper sync failed (unreachable)" to daily note, continue
+- If any individual state-gathering step fails → use `null` for that field, still sync the rest
+- Never let sync errors block the heartbeat or crash the agent
+
+## Manual Trigger
+
+Users can also trigger sync manually by running `clamper sync` from the terminal, which executes the same protocol programmatically.

package/skills/code-mentor/SKILL.md

@@ -0,0 +1,85 @@
+---
+name: code-mentor
+description: "Interactive programming tutor for all levels. Teaches through lessons, code review, debugging, and project mentoring."
+---
+
+# Code Mentor
+
+An AI programming tutor that adapts to the learner's level.
+
+## Before Starting
+
+Assess the user's level:
+- **Beginner** — New to programming. Clear explanations, foundational concepts, simple examples.
+- **Intermediate** — Knows basics. Best practices, patterns, problem-solving.
+- **Advanced** — Experienced. Architecture, optimization, system design.
+
+## Teaching Modes
+
+### 1. Concept Learning 📚
+Explain → Show example → Have them practice → Apply to real scenario.
+
+### 2. Code Review 🔍
+When user shares code:
+1. Acknowledge what's good first
+2. Identify issues by severity (bugs > performance > style)
+3. Explain WHY each suggestion matters
+4. Show the improved version
+5. Ask if they understand the reasoning
+
+### 3. Debugging (Socratic) 🐛
+Don't give the answer immediately. Guide discovery:
+1. "What do you expect this to do?"
+2. "What actually happens?"
+3. "What have you tried?"
+4. Narrow down: "What if you add a print here?"
+5. If stuck after 3 exchanges, explain directly
+
+### 4. Algorithm Practice 🧮
+1. Present the problem clearly
+2. Ask for their approach before coding
+3. Discuss time/space complexity
+4. Optimize together
+5. Connect to real-world use cases
+
+### 5. Project Mentoring 🏗️
+1. Help define scope (MVP first!)
+2. Break into milestones
+3. Guide architecture decisions
+4. Review progress incrementally
+5. Encourage shipping over perfecting
+
+## Key Principles
+- **Never write the whole solution** — teach them to fish
+- **Celebrate progress** — learning is hard, acknowledge effort
+- **Use analogies** — connect new concepts to things they know
+- **One concept at a time** — don't overwhelm
+- **Real examples** — abstract theory doesn't stick; show practical use
+
+## Common Beginner Pitfalls
+- Copying code without understanding it
+- Not reading error messages
+- Trying to learn everything at once
+- Not practicing enough (reading ≠ learning)
+- Perfectionism before fundamentals
+
+## Language-Specific Quick Starts
+
+### Python
+```python
+# Variables, functions, loops — the essentials
+def greet(name):
+    return f"Hello, {name}!"
+
+for i in range(5):
+    print(greet(f"User {i}"))
+```
+
+### JavaScript
+```javascript
+// Same concepts, different syntax
+const greet = (name) => `Hello, ${name}!`;
+for (let i = 0; i < 5; i++) {
+    console.log(greet(`User ${i}`));
+}
+```

package/skills/csv-pipeline/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: csv-pipeline
+description: Process, transform, analyze, and report on CSV and JSON data files.
+---
+
+# CSV Data Pipeline
+
+Process tabular data (CSV, TSV, JSON, JSON Lines) using command-line tools and Python.
+
+## Quick Operations
+
+### Inspect
+```bash
+head -5 data.csv                                    # Preview
+tail -n +2 data.csv | wc -l                         # Row count
+head -1 data.csv                                    # Column headers
+tail -n +2 data.csv | cut -d',' -f3 | sort -u | wc -l  # Unique values in col 3
+```
+
+### Filter with awk
+```bash
+awk -F',' 'NR==1 || $3 > 100' data.csv > filtered.csv
+awk -F',' 'NR==1 || $2 ~ /pattern/' data.csv > matched.csv
+awk -F',' 'NR>1 {sum += $4} END {print sum}' data.csv
+```
+
+### Sort & Deduplicate
+```bash
+head -1 data.csv > sorted.csv && tail -n +2 data.csv | sort -t',' -k2 -n >> sorted.csv
+awk -F',' '!seen[$2]++' data.csv > deduped.csv
+```
+
+### Format Conversion
+```bash
+# CSV → JSON (Python one-liner)
+python3 -c "import csv,json,sys; print(json.dumps(list(csv.DictReader(open('data.csv')))))"
+
+# JSON → CSV
+python3 -c "
+import csv,json,sys
+data=json.load(open('data.json'))
+w=csv.DictWriter(sys.stdout,fieldnames=data[0].keys())
+w.writeheader(); w.writerows(data)
+" > data.csv
+```
+
+## Python Operations
+
+```python
+import csv, json
+
+def read_csv(path, delimiter=','):
+    with open(path, newline='', encoding='utf-8') as f:
+        return list(csv.DictReader(f, delimiter=delimiter))
+
+def write_csv(rows, path, delimiter=','):
+    if not rows: return
+    with open(path, 'w', newline='', encoding='utf-8') as f:
+        w = csv.DictWriter(f, fieldnames=rows[0].keys(), delimiter=delimiter)
+        w.writeheader(); w.writerows(rows)
+
+def group_by(rows, key):
+    groups = {}
+    for r in rows:
+        groups.setdefault(r[key], []).append(r)
+    return groups
+
+def aggregate(rows, group_key, agg_key, func='sum'):
+    groups = group_by(rows, group_key)
+    results = []
+    for k, v in groups.items():
+        vals = [float(r[agg_key]) for r in v if r[agg_key]]
+        agg = sum(vals) if func == 'sum' else sum(vals)/len(vals) if func == 'avg' else max(vals) if func == 'max' else min(vals)
+        results.append({group_key: k, f'{func}_{agg_key}': agg, 'count': len(v)})
+    return results
+```
+
+## Tips
+- Always check encoding: `file -i data.csv`
+- Handle quoted fields with commas inside them (use `csv` module, not `split`)
+- For large files (>100MB), process line by line instead of loading into memory
+- Validate data types before aggregating — one bad row can ruin calculations

package/skills/developer/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: developer
+description: Write clean, maintainable code with debugging, testing, and architectural best practices.
+---
+
+# Software Development
+
+## Code Quality
+- Readable code beats clever code — you'll read it 10x more than write it
+- Functions do one thing — if you need "and" to describe it, split it
+- Name things by what they do, not how
+- Delete dead code — version control remembers
+- Consistent style matters more than which style
+
+## Debugging
+- Read the error message completely — the answer is often there
+- Reproduce before fixing — if you can't trigger it, you can't verify the fix
+- Binary search: comment out half the code to find the problem
+- Check the obvious first — typos, wrong file, stale cache, wrong env
+- `console.log` liberally when stuck — assumptions are usually wrong
+
+## Testing
+- Test behavior, not implementation
+- One assertion per test when possible
+- Name tests as sentences: `should return empty array when no items match`
+- Mock external dependencies, not internal logic
+- Fast tests run often, slow tests get skipped
+
+## Error Handling
+- Fail fast and loud — silent failures create debugging nightmares
+- Catch specific exceptions, not generic
+- Log enough context to debug (error type alone isn't enough)
+- User-facing errors should be helpful
+- Don't catch exceptions you can't handle
+
+## Architecture
+- Start simple, add complexity when needed
+- Separate concerns — UI, business logic, data access
+- Dependencies flow inward — core logic shouldn't know about frameworks
+- Configuration separate from code
+- Document decisions (ADRs), not just code
+
+## Performance
+- Measure before optimizing — intuition is usually wrong
+- Database queries are usually the bottleneck
+- Caching solves many problems but creates invalidation headaches
+- Make it work, make it right, make it fast (in that order)
+
+## Dependencies
+- Evaluate before adding — every dependency is code you don't control
+- Pin versions — "latest" breaks builds
+- Fewer dependencies is better — each adds supply chain risk
+
+## Working in Existing Codebases
+- Match existing patterns — consistency beats preference
+- Understand before changing — read tests, check git history
+- Don't refactor while fixing bugs — separate commits

package/skills/image/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: image
+description: Process, optimize, and manage images with format selection, compression, and platform specs.
+---
+
+# Image Processing
+
+## Format Selection
+
+| Content | Format | Reason |
+|---------|--------|--------|
+| Photos | WebP (JPEG fallback) | 25-35% smaller |
+| Icons, logos | SVG | Scalable, tiny |
+| Screenshots | PNG | Sharp edges preserved |
+| Transparency + photo | WebP or PNG-24 | Alpha support |
+| Animation | WebP or MP4 | NOT GIF (5-10x larger) |
+
+## File Size Budgets
+- Hero images: MAX 200KB (ideally <150KB)
+- Content images: MAX 100KB
+- Thumbnails: MAX 30KB
+- Icons (raster): MAX 5KB
+
+## Quality Levels
+
+| Format | Hero | General | Thumbnails |
+|--------|------|---------|------------|
+| JPEG | 80-85% | 70-75% | 60-65% |
+| WebP | 80-82% | 72-78% | 60-70% |
+
+## Common Operations
+
+```bash
+# Resize (ImageMagick)
+convert input.jpg -resize 800x600 output.jpg
+
+# Convert format
+convert input.png -quality 80 output.webp
+
+# Batch resize
+for f in *.jpg; do convert "$f" -resize 1200x -quality 80 "optimized/$f"; done
+
+# Strip metadata (reduce size)
+convert input.jpg -strip output.jpg
+
+# Create thumbnail
+convert input.jpg -thumbnail 200x200^ -gravity center -extent 200x200 thumb.jpg
+
+# Get image info
+identify -verbose image.jpg | head -20
+```
+
+## Retina/HiDPI
+- 2x required for standard Retina
+- 400px displayed needs 800px source
+- 3x only for iPhone Plus/Max
+
+## Social Media Dimensions
+- **Instagram Post:** 1080×1080
+- **Instagram Story:** 1080×1920
+- **Twitter/X Post:** 1200×675
+- **LinkedIn Post:** 1200×627
+- **YouTube Thumbnail:** 1280×720
+- **Facebook Post:** 1200×630
+
+## Checklist Before Processing
+- [ ] Target format determined
+- [ ] Color profile: sRGB for web
+- [ ] Dimensions/aspect ratio defined
+- [ ] Compression quality set
+- [ ] Metadata stripped for web use

package/skills/json/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: json
+description: Work with JSON data structures, APIs, and serialization effectively.
+---
+
+# JSON
+
+## Schema & Validation
+- Validate against JSON Schema before processing untrusted input
+- Use `additionalProperties: false` to reject unknown fields in strict contexts
+
+## Naming Conventions
+- `camelCase` for JS ecosystems, `snake_case` for Python/Ruby
+- Plural for collections: `"users": []` not `"user": []`
+
+## Null Handling
+- Distinguish "field is null" from "field is absent"
+- Omit optional fields rather than sending `null`
+
+## Dates & Times
+- Always ISO 8601: `"2024-01-15T14:30:00Z"`
+- Include timezone or use UTC with `Z` suffix
+
+## Numbers & IDs
+- Large IDs as strings: `"id": "9007199254740993"` (JS loses precision above 2^53)
+- Money as string or integer cents — never float
+
+## Structure
+- Keep nesting shallow — 3 levels max
+- Consistent API envelope: `{"data": ..., "meta": ..., "errors": ...}`
+- Paginate large arrays — never return unbounded lists
+
+## API Response Patterns
+- Errors as objects: `{"code": "INVALID_EMAIL", "message": "...", "field": "email"}`
+- Include request ID for debugging
+- Return created/updated resource in response
+
+## CLI Operations
+```bash
+# Pretty print
+cat data.json | python3 -m json.tool
+
+# Extract field with jq
+cat data.json | jq '.users[0].name'
+
+# Filter array
+cat data.json | jq '.items[] | select(.price > 10)'
+
+# Transform
+cat data.json | jq '{name: .first, email: .contact.email}'
+
+# Validate JSON
+python3 -c "import json; json.load(open('data.json')); print('Valid')"
+```
+
+## Parsing Safety
+- `__proto__` key can pollute prototypes — sanitize or use `Object.create(null)`
+- Parse in try/catch — malformed JSON from external sources is common
+- Strip BOM (`\uFEFF`) from file input

package/skills/productivity/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: productivity
+description: "Plan, focus, and complete work with energy management, time blocking, and practical boundaries."
+---
+
+# Productivity
+
+Help users plan, focus, and complete work effectively.
+
+## Energy Management (Not Just Time)
+
+People have ~4 hours of peak cognitive work per day. Help them use it wisely.
+
+**Energy levels:**
+- 🟢 **Peak** — Deep work, complex problems, creative tasks
+- 🟡 **Medium** — Meetings, communication, routine coding
+- 🔴 **Low** — Admin, email, filing, simple tasks
+
+**Ask:** "When do you feel most focused?" then schedule their hardest work there.
+
+## Time Blocking
+
+```
+09:00–11:00  🟢 Deep Work (no meetings, no Slack)
+11:00–12:00  🟡 Communication (email, messages, reviews)
+12:00–13:00  🔴 Lunch + low-energy tasks
+13:00–14:30  🟡 Collaborative work / meetings
+14:30–16:00  🟢 Second wind — focused work
+16:00–17:00  🔴 Planning tomorrow, admin, wrap-up
+```
+
+## Task Initiation (Getting Started)
+
+The hardest part is starting. Use these techniques:
+1. **2-Minute Rule** — If it takes <2 min, do it now
+2. **5-Minute Commit** — "Just work on it for 5 minutes" (momentum kicks in)
+3. **Next Physical Action** — Don't write "work on project", write "open file X and read section Y"
+4. **Pomodoro** — 25 min work + 5 min break. 4 rounds then 15-30 min break.
+
+## "Good Enough" Thresholds
+
+Help users avoid perfectionism:
+- **First draft:** 60% quality is fine — just get it down
+- **Internal doc:** 80% is enough — don't polish what 3 people will read
+- **Client-facing:** 95% — worth the extra effort
+- **Published/permanent:** 98% — justify the remaining 2%
+
+## When Users Are Stuck
+
+1. Ask what's blocking them (unclear task? too big? not motivated?)
+2. Break it into the smallest possible next step
+3. Offer to work on it together (rubber duck debugging for productivity)
+4. Suggest a context switch if they've been stuck >30 min
+
+## Planning a Day
+
+When asked to help plan a day:
+1. List everything they need to do
+2. Estimate time for each (add 50% buffer)
+3. Match tasks to energy levels
+4. Schedule the hardest 1-2 things during peak energy
+5. Leave 20% of the day unscheduled (for surprises)
+
+## Common Traps to Avoid
+- ❌ "Organize your task list" as a procrastination tool
+- ❌ Suggesting complex systems (keep it simple)
+- ❌ Guilt-tripping about productivity
+- ❌ Assuming everyone works the same way

package/skills/quick-reminders/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: quick-reminders
+description: "One-shot reminders (<48h) via cron or background sleep process."
+---
+
+# Quick Reminders
+
+Set one-shot reminders for up to 48 hours ahead. For longer timelines, use a calendar.
+
+## Setting a Reminder
+
+Use `at` command (if available) or background sleep:
+
+```bash
+# Using 'at' (preferred)
+echo 'openclaw message send --target CHAT_ID --message "Hey, time for your meeting!"' | at now + 30 minutes
+
+# Using nohup + sleep (fallback)
+nohup bash -c 'sleep 1800 && openclaw message send --target CHAT_ID --message "Hey, time for your meeting!"' &>/dev/null &
+echo $! > /tmp/reminder-$(date +%s).pid
+```
+
+## Using OpenClaw Cron
+
+```bash
+# Remind at specific time today
+openclaw cron add --schedule "30 14 * * *" --once --command 'openclaw message send --target CHAT_ID --message "Meeting in 30 min!"'
+```
+
+## Composing Reminder Messages
+
+Sound like a friend texting, not a system notification:
+
+**Don't:**
+- "Reminder: call John"
+- "This is your reminder to..."
+
+**Do:**
+- "Hey, you wanted to call John"
+- "Time to call John back 📞"
+- "So... dishwasher time 🍽️"
+
+**Guidelines:**
+- Casual openers: "Hey", "So...", "Heads up"
+- Light humor when it fits
+- Keep it short — one line
+- Must make sense out of context (user reads it hours later)
+
+## Listing Active Reminders
+
+```bash
+# Check at queue
+atq
+
+# Check background sleep processes
+ps aux | grep "sleep.*openclaw message" | grep -v grep
+```
+
+## Canceling
+
+```bash
+# Cancel at job
+atrm JOB_ID
+
+# Kill background process
+kill $(cat /tmp/reminder-*.pid)
+```
+
+## Guardrail
+If reminder is **2+ days out**, suggest a calendar event instead — sleep processes and `at` jobs don't survive reboots reliably.