mkdir -p ~/.wolffish/workspace/brain/cerebellum/my-capability

---
name: my-capability
description: What this capability does in one sentence
triggers:
  - keyword1
  - keyword2
tools:
  - name: my_tool
    description: What this tool does
    parameters:
      type: object
      properties:
        input:
          type: string
          description: The input to process
      required:
        - input
---

# My Capability

Instructions for the LLM on how to use this capability.

When the user asks about [topic], use the `my_tool` tool with the relevant input.
Always [specific behavior guideline].
Never [specific constraint].

export default {
  name: 'my-capability',
  tools: ['my_tool'],

  async init(context) {
    // context.pluginDir — path to this plugin folder
    // context.workspaceRoot — path to ~/.wolffish/workspace/
  },

  async execute(toolName, args) {
    if (toolName === 'my_tool') {
      // Your logic here
      const result = doSomething(args.input)
      return { success: true, output: result }
    }
    return { success: false, output: '', error: `Unknown tool: ${toolName}` }
  },

  async destroy() {
    // Cleanup on shutdown
  }
}

danger_patterns:
  - "dangerous_regex_here"
confirm_patterns:
  - "risky_but_allowed_regex"

~/.wolffish/workspace/brain/cerebellum/weather/
├── SKILL.md
└── plugin/
    └── index.mjs

---
name: weather
description: Get the current weather for any city or place
triggers:
  - weather
  - temperature
  - forecast
  - how hot
  - how cold
  - is it raining
tools:
  - name: weather_get
    description: Get current weather conditions for a city, town, or place name.
    parameters:
      type: object
      properties:
        location:
          type: string
          description: City or place name, e.g. "Tokyo" or "Riyadh, Saudi Arabia"
        units:
          type: string
          enum: [celsius, fahrenheit]
          description: Temperature units. Defaults to celsius.
      required:
        - location
---

# Weather

When the user asks about the weather, temperature, or forecast for a place,
call `weather_get` with the location they named.

- If they don't specify units, use celsius (the API default).
- If they don't name a location, ask which city before calling the tool — never guess.
- Data comes from Open-Meteo (no API key). Report sky, temperature, humidity, and
  wind in one natural sentence.

// Real, working plugin — no API key required.
// Open-Meteo docs: https://open-meteo.com/en/docs

const GEOCODE = 'https://geocoding-api.open-meteo.com/v1/search'
const FORECAST = 'https://api.open-meteo.com/v1/forecast'

// WMO weather-interpretation codes → human text
const SKY = {
  0: 'clear sky', 1: 'mainly clear', 2: 'partly cloudy', 3: 'overcast',
  45: 'fog', 48: 'rime fog',
  51: 'light drizzle', 53: 'drizzle', 55: 'dense drizzle',
  61: 'light rain', 63: 'rain', 65: 'heavy rain',
  71: 'light snow', 73: 'snow', 75: 'heavy snow',
  80: 'rain showers', 81: 'rain showers', 82: 'violent rain showers',
  95: 'thunderstorm', 96: 'thunderstorm with hail', 99: 'severe thunderstorm'
}

export default {
  name: 'weather',
  tools: ['weather_get'],

  async execute(toolName, args) {
    if (toolName !== 'weather_get') {
      return { success: false, output: '', error: `Unknown tool: ${toolName}` }
    }

    const location = String(args.location ?? '').trim()
    if (!location) {
      return { success: false, output: '', error: 'Missing required "location" argument' }
    }
    const units = args.units === 'fahrenheit' ? 'fahrenheit' : 'celsius'

    try {
      // 1) Resolve the place name to coordinates
      const geoRes = await fetch(
        `${GEOCODE}?name=${encodeURIComponent(location)}&count=1&language=en&format=json`
      )
      if (!geoRes.ok) {
        return { success: false, output: '', error: `Geocoding failed (HTTP ${geoRes.status})` }
      }
      const place = (await geoRes.json()).results?.[0]
      if (!place) {
        return { success: false, output: '', error: `No location found for "${location}"` }
      }

      // 2) Fetch current conditions for those coordinates
      const res = await fetch(
        `${FORECAST}?latitude=${place.latitude}&longitude=${place.longitude}` +
        `&current=temperature_2m,relative_humidity_2m,wind_speed_10m,weather_code` +
        `&temperature_unit=${units}`
      )
      if (!res.ok) {
        return { success: false, output: '', error: `Forecast failed (HTTP ${res.status})` }
      }

      const data = await res.json()
      const c = data.current
      const u = data.current_units
      const sky = SKY[c.weather_code] ?? `code ${c.weather_code}`
      const where = [place.name, place.admin1, place.country].filter(Boolean).join(', ')

      return {
        success: true,
        output:
          `Weather in ${where}: ${sky}, ${c.temperature_2m}${u.temperature_2m}, ` +
          `humidity ${c.relative_humidity_2m}${u.relative_humidity_2m}, ` +
          `wind ${c.wind_speed_10m} ${u.wind_speed_10m}.`
      }
    } catch (err) {
      return { success: false, output: '', error: `Weather lookup failed: ${err.message}` }
    }
  }
}

---
name: planning
description: Think before acting.
triggers:
  - "*"
tools: []
---

# Planning

Before executing any multi-step task, state your plan first...