pocketrb 0.1.0

data/lib/pocketrb/skills/builtin/github/SKILL.md

@@ -0,0 +1,113 @@
+---
+name: github
+description: "Interact with GitHub using the `gh` CLI"
+always: false
+triggers:
+  - github
+  - gh
+  - pull request
+  - pr
+  - issue
+  - repo
+  - workflow
+  - actions
+requires:
+  - bin:gh
+metadata:
+  pocketrb:
+    emoji: "🐙"
+---
+
+# GitHub Skill
+
+Use the `gh` CLI for GitHub operations. This skill provides guidance on common GitHub workflows.
+
+## Prerequisites
+
+The `gh` CLI must be installed and authenticated:
+```bash
+# Install (macOS)
+brew install gh
+
+# Install (Linux)
+# See https://github.com/cli/cli/blob/trunk/docs/install_linux.md
+
+# Authenticate
+gh auth login
+```
+
+## Common Commands
+
+### Pull Requests
+
+```bash
+# List PRs
+gh pr list --repo owner/repo
+
+# View PR details
+gh pr view 55 --repo owner/repo
+
+# Check PR status/checks
+gh pr checks 55 --repo owner/repo
+
+# Create PR
+gh pr create --title "Title" --body "Description"
+
+# Merge PR
+gh pr merge 55 --squash --delete-branch
+
+# Review PR
+gh pr diff 55 --repo owner/repo
+```
+
+### Issues
+
+```bash
+# List issues
+gh issue list --repo owner/repo
+
+# View issue
+gh issue view 123 --repo owner/repo
+
+# Create issue
+gh issue create --title "Bug" --body "Description"
+
+# Close issue
+gh issue close 123
+```
+
+### Workflows / Actions
+
+```bash
+# List workflow runs
+gh run list --repo owner/repo --limit 10
+
+# View run details
+gh run view 12345 --repo owner/repo
+
+# Watch a run
+gh run watch 12345 --repo owner/repo
+
+# Rerun failed jobs
+gh run rerun 12345 --failed
+```
+
+### API Access
+
+```bash
+# Get PR info as JSON
+gh api repos/owner/repo/pulls/55 --jq '.title'
+
+# Get issue comments
+gh api repos/owner/repo/issues/123/comments
+
+# Create a comment
+gh api repos/owner/repo/issues/123/comments -f body="Comment text"
+```
+
+## Tips
+
+- Use `--repo owner/repo` or `-R owner/repo` to specify repository
+- Use `--json field1,field2` to get specific fields as JSON
+- Use `--jq '.field'` to filter JSON output
+- Most commands support `--web` to open in browser

data/lib/pocketrb/skills/builtin/proactive/SKILL.md

@@ -0,0 +1,101 @@
+---
+name: proactive
+description: "Be proactive - schedule follow-ups, reminders, and check-ins"
+always: true
+metadata:
+  emoji: "⏰"
+---
+
+# Proactive Agent Skill
+
+You have the ability to schedule tasks for yourself using the `cron` tool. Use this to be genuinely helpful and proactive.
+
+## When to Create Scheduled Tasks
+
+**DO schedule tasks when:**
+
+- User mentions a deadline or future event → offer to remind them
+- User starts a project → offer daily/weekly check-ins
+- You're waiting on external results → schedule a follow-up check
+- User seems overwhelmed → offer to nudge about priorities
+- A task has natural follow-up steps → schedule the next step
+- User asks you to remind them about anything
+- User says "remind me", "ping me", "follow up", "check back", etc.
+
+**DON'T over-schedule:**
+
+- Ask before creating recurring jobs (daily, weekly)
+- One-time reminders are fine to create proactively
+- Don't spam - consolidate related reminders
+
+## Cron Tool Parameters
+
+The `cron` tool accepts these parameters:
+
+- **action**: "add", "list", "remove", "enable", "disable"
+- **name**: A short label for the job (required for add)
+- **message**: What to send when job fires (required for add)
+- **schedule_type**: "at" (one-time), "every" (interval), "cron" (expression)
+- **schedule_value**: ISO datetime for "at", seconds for "every", cron expression for "cron"
+- **deliver**: true to send message directly, false to wake agent with message
+- **job_id**: Job ID for remove/enable/disable actions
+
+## Schedule Examples
+
+### One-time Reminder
+Schedule a reminder for a specific time:
+- schedule_type: "at"
+- schedule_value: ISO datetime like "2026-02-04T09:00:00"
+
+### Interval-based (every N seconds)
+Run every X seconds (minimum 60):
+- schedule_type: "every"
+- schedule_value: "3600" (every hour), "7200" (every 2 hours), "86400" (daily)
+
+### Cron Expression
+Standard cron syntax (minute hour day month weekday):
+- schedule_type: "cron"
+- schedule_value: "0 9 * * *" (9am daily), "0 9 * * 1" (9am Mondays), "30 14 * * *" (2:30pm daily)
+
+## Proactive Patterns
+
+### User Asks for Reminder
+When user says "remind me about X" or "ping me in Y":
+1. Parse the time/interval from their request
+2. Create the job immediately using the cron tool
+3. Confirm what you scheduled
+
+### Research Follow-up
+When you start research that takes time:
+> "I'll schedule a follow-up for tomorrow to continue the competitor analysis."
+
+### Deadline Tracking
+When user mentions a deadline:
+> "Your pitch is on Friday. Want me to check in Wednesday to review the deck?"
+
+### Project Momentum
+For ongoing projects:
+> "Should I do a weekly check-in on the Zakiya project? I can nudge you every Monday at 10am."
+
+### Waiting on External
+When waiting for something:
+> "The domain registration takes 24-48 hours. I'll check back tomorrow afternoon."
+
+## Message Format
+
+When a scheduled job fires, your message will be delivered to the same channel. Write messages that:
+
+- Provide context (what this is about)
+- Are actionable (what should happen next)
+- Feel natural, not robotic
+
+**Good:** "Hey! Following up on the trademark search we discussed. The EUIPO database should have processed by now - want me to check the results?"
+
+**Bad:** "SCHEDULED REMINDER: Trademark search follow-up [job_id: xyz]"
+
+## Transparency
+
+Always tell the user when you create a scheduled task:
+> "Got it! I've scheduled a reminder for tomorrow at 9am to follow up on this."
+
+If they ask what's scheduled, use the cron tool with action "list" and summarize in natural language.

data/lib/pocketrb/skills/builtin/reflection/SKILL.md

@@ -0,0 +1,109 @@
+---
+name: reflection
+description: "Periodic self-assessment, goal tracking, and proactive improvement"
+always: true
+metadata:
+  emoji: "🪞"
+---
+
+# Reflection Skill
+
+You have the ability to reflect, plan, and improve over time. Use heartbeat and scheduled tasks to maintain continuity between conversations.
+
+## When to Reflect
+
+### During Conversations
+- At the end of complex tasks, note what worked and what didn't
+- When user expresses frustration, consider what could be improved
+- After completing a project milestone, summarize progress
+
+### During Heartbeats
+When the heartbeat wakes you up, check:
+1. **HEARTBEAT.md** - Any pending tasks or instructions?
+2. **Recent activity** - What was accomplished recently?
+3. **Open loops** - Any unfinished work that needs follow-up?
+
+If nothing needs attention, respond with: HEARTBEAT_OK
+
+### Scheduled Reflection
+You can schedule periodic reflection sessions:
+- Daily review: "What was accomplished? What's pending?"
+- Weekly planning: "What are the goals for next week?"
+- Monthly retrospective: "What patterns am I seeing?"
+
+## What to Reflect On
+
+### User Patterns
+- How does the user prefer to communicate?
+- What topics come up frequently?
+- What frustrates them? What delights them?
+
+### Task Patterns
+- What types of tasks are most common?
+- Where do I tend to struggle or make mistakes?
+- What could be automated or streamlined?
+
+### Knowledge Gaps
+- What questions couldn't I answer well?
+- What domains need more learning?
+- What tools or skills would be useful to develop?
+
+## Storing Reflections
+
+Use the memory tool to store durable insights:
+
+### Good candidates for memory:
+- User preferences discovered through interaction
+- Project milestones and decisions
+- Recurring patterns or workflows
+- Important context about people/companies
+- Lessons learned from mistakes
+
+### Not worth storing:
+- One-off transient information
+- Things the user explicitly said are temporary
+- Trivial details without lasting value
+
+## Proactive Improvement
+
+When you identify an improvement opportunity:
+
+1. **Ask before implementing** - "I noticed X pattern. Should I Y?"
+2. **Suggest don't dictate** - User has final say on workflows
+3. **Start small** - One change at a time, evaluate results
+
+### Examples
+
+**Good:** "I've noticed you often ask about project X status on Mondays. Should I schedule a Monday morning summary?"
+
+**Good:** "The last three times we discussed Y, you mentioned Z constraint. Should I add that to my working memory?"
+
+**Bad:** Silently changing behavior without user awareness
+
+## Heartbeat Response Format
+
+When responding to heartbeat prompts:
+
+### If action needed:
+```
+Checking HEARTBEAT.md...
+Found pending task: [task description]
+Taking action: [what you're doing]
+```
+
+### If nothing needed:
+```
+HEARTBEAT_OK
+```
+
+The HEARTBEAT_OK token tells the system no further action is needed.
+
+## Continuous Learning
+
+Track what you learn in each conversation:
+- New facts about the user's world
+- Preferences and communication style
+- Domain knowledge relevant to their work
+- Tool usage patterns and shortcuts
+
+Store significant learnings to memory so they persist across sessions.

data/lib/pocketrb/skills/builtin/tmux/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: tmux
+description: "Remote-control tmux sessions for interactive CLIs"
+always: false
+triggers:
+  - tmux
+  - terminal
+  - session
+  - multiplexer
+requires:
+  - bin:tmux
+metadata:
+  pocketrb:
+    emoji: "🧵"
+    os:
+      - darwin
+      - linux
+---
+
+# Tmux Skill
+
+Control tmux sessions via socket for isolated agent workspaces. This allows running and interacting with persistent terminal sessions.
+
+## Socket Setup
+
+Use a dedicated socket directory to avoid conflicts:
+
+```bash
+SOCKET_DIR="${POCKETRB_TMUX_SOCKET_DIR:-${TMPDIR:-/tmp}/pocketrb-tmux-sockets}"
+mkdir -p "$SOCKET_DIR"
+SOCKET="$SOCKET_DIR/pocketrb.sock"
+```
+
+## Basic Commands
+
+### Session Management
+
+```bash
+# Create a new session
+tmux -S "$SOCKET" new-session -d -s mysession
+
+# Create session with initial command
+tmux -S "$SOCKET" new-session -d -s mysession "python3"
+
+# List sessions
+tmux -S "$SOCKET" list-sessions
+
+# Kill a session
+tmux -S "$SOCKET" kill-session -t mysession
+
+# Attach to session (interactive)
+tmux -S "$SOCKET" attach -t mysession
+```
+
+### Sending Commands
+
+```bash
+# Send keys (commands) to a session
+tmux -S "$SOCKET" send-keys -t mysession "ls -la" Enter
+
+# Send literal text (no Enter)
+tmux -S "$SOCKET" send-keys -t mysession -l "some text"
+
+# Send special keys
+tmux -S "$SOCKET" send-keys -t mysession C-c  # Ctrl+C
+tmux -S "$SOCKET" send-keys -t mysession C-d  # Ctrl+D
+tmux -S "$SOCKET" send-keys -t mysession Up   # Arrow up
+```
+
+### Capturing Output
+
+```bash
+# Capture visible pane content
+tmux -S "$SOCKET" capture-pane -p -t mysession
+
+# Capture with history (last 200 lines)
+tmux -S "$SOCKET" capture-pane -p -J -t mysession -S -200
+
+# Capture to file
+tmux -S "$SOCKET" capture-pane -p -t mysession > output.txt
+```
+
+## Common Patterns
+
+### Run Command and Get Output
+
+```bash
+# Send command
+tmux -S "$SOCKET" send-keys -t mysession "python3 script.py" Enter
+
+# Wait for completion (simple approach)
+sleep 2
+
+# Capture output
+tmux -S "$SOCKET" capture-pane -p -J -t mysession -S -50
+```
+
+### Interactive Python/REPL Session
+
+```bash
+# Start Python session
+tmux -S "$SOCKET" new-session -d -s python "python3"
+
+# Send Python commands
+tmux -S "$SOCKET" send-keys -t python "import os" Enter
+tmux -S "$SOCKET" send-keys -t python "print(os.getcwd())" Enter
+
+# Get output
+sleep 1
+tmux -S "$SOCKET" capture-pane -p -t python
+```
+
+### SSH Session
+
+```bash
+# Start SSH session
+tmux -S "$SOCKET" new-session -d -s remote "ssh user@host"
+
+# Wait for connection, then send commands
+sleep 3
+tmux -S "$SOCKET" send-keys -t remote "ls -la" Enter
+```
+
+## Tips
+
+- Use `-l` flag with `send-keys` for literal text to avoid interpretation
+- The `-J` flag in `capture-pane` joins wrapped lines
+- Use `-S -N` in `capture-pane` to capture last N lines of history
+- Clean up sessions when done to avoid resource leaks
+- Use unique session names to avoid conflicts

data/lib/pocketrb/skills/builtin/weather/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: weather
+description: "Get weather forecasts using wttr.in (no API key required)"
+always: false
+triggers:
+  - weather
+  - forecast
+  - temperature
+  - rain
+  - snow
+requires:
+  - bin:curl
+metadata:
+  pocketrb:
+    emoji: "🌤️"
+---
+
+# Weather Skill
+
+Get weather data using wttr.in - a console-oriented weather service that requires no API key.
+
+## Quick Commands
+
+### Current Weather
+
+```bash
+# Simple one-line format
+curl -s "wttr.in/London?format=3"
+# Output: London: ⛅️ +8°C
+
+# With more details
+curl -s "wttr.in/London?format=%l:+%c+%t+%h+%w"
+# Output: London: ⛅️ +8°C 65% ↙15km/h
+
+# Current conditions only
+curl -s "wttr.in/London?0"
+```
+
+### Full Forecast
+
+```bash
+# 3-day forecast (default)
+curl -s "wttr.in/London"
+
+# 1-day forecast
+curl -s "wttr.in/London?1"
+
+# 2-day forecast
+curl -s "wttr.in/London?2"
+```
+
+### Format Options
+
+```bash
+# Metric units (Celsius, km/h)
+curl -s "wttr.in/London?m"
+
+# Imperial units (Fahrenheit, mph)
+curl -s "wttr.in/London?u"
+
+# Compact format (no terminal colors)
+curl -s "wttr.in/London?T"
+
+# Plain text (no ANSI)
+curl -s "wttr.in/London?T"
+```
+
+## Custom Format Strings
+
+Use `format=` for custom output:
+
+| Symbol | Meaning |
+|--------|---------|
+| %c | Weather condition icon |
+| %C | Weather condition text |
+| %t | Temperature |
+| %f | "Feels like" temperature |
+| %h | Humidity |
+| %w | Wind |
+| %l | Location |
+| %m | Moon phase |
+| %p | Precipitation (mm) |
+| %P | Pressure |
+| %S | Sunrise |
+| %s | Sunset |
+
+### Examples
+
+```bash
+# Minimal
+curl -s "wttr.in/Tokyo?format=%c+%t"
+# ☀️ +15°C
+
+# Detailed
+curl -s "wttr.in/Tokyo?format=%l:+%C,+%t+(%f),+%h+humidity,+wind+%w"
+# Tokyo: Sunny, +15°C (+13°C), 45% humidity, wind ↗12km/h
+
+# JSON format
+curl -s "wttr.in/Tokyo?format=j1" | jq '.current_condition[0].temp_C'
+```
+
+## Location Formats
+
+```bash
+# City name
+curl -s "wttr.in/Paris"
+
+# City, Country
+curl -s "wttr.in/Paris,France"
+
+# Airport code
+curl -s "wttr.in/JFK"
+
+# Coordinates
+curl -s "wttr.in/51.5,-0.1"
+
+# IP-based (auto-detect)
+curl -s "wttr.in"
+
+# Landmark
+curl -s "wttr.in/Eiffel+Tower"
+```
+
+## Tips
+
+- Add `?lang=XX` for different languages (e.g., `?lang=de` for German)
+- Use `?n` to disable colors in narrow terminals
+- Append `?Q` for quiet mode (no "Weather report" header)
+- For scripts, use `?format=j1` for full JSON data
+- Moon phase: `curl -s "wttr.in/Moon"`

data/lib/pocketrb/skills/create_tool.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Skills
+    # Tool for creating new skills at runtime
+    class CreateTool < Tools::Base
+      def name
+        "skill_create"
+      end
+
+      def description
+        "Create a new skill. Skills are reusable prompts/instructions that can be loaded into context. Use this to teach yourself new capabilities."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            skill_name: {
+              type: "string",
+              description: "Name of the skill (lowercase, hyphens allowed, e.g., 'code-review')"
+            },
+            skill_description: {
+              type: "string",
+              description: "Brief description of what the skill does"
+            },
+            content: {
+              type: "string",
+              description: "The skill content - instructions, prompts, or guidelines"
+            },
+            triggers: {
+              type: "array",
+              items: { type: "string" },
+              description: "Keywords that automatically trigger this skill"
+            },
+            always: {
+              type: "boolean",
+              description: "Whether this skill should always be loaded (default: false)"
+            }
+          },
+          required: %w[skill_name skill_description content]
+        }
+      end
+
+      def execute(skill_name:, skill_description:, content:, triggers: nil, always: false)
+        # Validate skill name
+        unless valid_skill_name?(skill_name)
+          return error("Invalid skill name. Use lowercase letters, numbers, and hyphens only.")
+        end
+
+        # Create skill directory
+        skill_dir = workspace.join("skills", skill_name)
+
+        return error("Skill '#{skill_name}' already exists. Use skill_modify to update it.") if skill_dir.exist?
+
+        FileUtils.mkdir_p(skill_dir)
+
+        # Build skill content with frontmatter
+        skill_content = build_skill_file(skill_name, skill_description, content, triggers, always)
+
+        # Write SKILL.md
+        skill_file = skill_dir.join("SKILL.md")
+        File.write(skill_file, skill_content)
+
+        # Update TOOLS.md if it exists
+        update_tools_documentation(skill_name, skill_description)
+
+        success("Created skill '#{skill_name}' at #{skill_file}")
+      end
+
+      private
+
+      def valid_skill_name?(name)
+        name.match?(/\A[a-z][a-z0-9-]*\z/)
+      end
+
+      def build_skill_file(name, description, content, triggers, always)
+        metadata = {
+          "name" => name,
+          "description" => description
+        }
+        metadata["triggers"] = triggers if triggers && !triggers.empty?
+        metadata["always"] = true if always
+
+        <<~MD
+          ---
+          #{metadata.to_yaml.lines[1..].join}---
+
+          #{content}
+        MD
+      end
+
+      def update_tools_documentation(skill_name, description)
+        tools_file = workspace.join("TOOLS.md")
+        return unless tools_file.exist?
+
+        content = File.read(tools_file)
+
+        # Find skills section and add new skill
+        if content.include?("## Skills")
+          # Add to existing skills section
+          skills_section_end = content.index(/\n##[^#]/, content.index("## Skills") + 1) || content.length
+          insert_point = skills_section_end
+
+          new_entry = "\n- **#{skill_name}**: #{description}"
+
+          new_content = content[0...insert_point] + new_entry + content[insert_point..]
+          File.write(tools_file, new_content)
+        end
+      rescue StandardError => e
+        Pocketrb.logger.warn("Failed to update TOOLS.md: #{e.message}")
+      end
+    end
+  end
+end