Skills

---
name: weather-lookup
description: Fetches current weather conditions and forecast for a location.
script: index.js
language: javascript
install: bun install
---

## When to use
Use this skill whenever the user asks about current weather, temperature,
rain, wind, or a forecast for a specific location. Do not use it for
historical weather data — it only covers the current 7-day window.

## Input
Receives a JSON object via stdin with fields: `location` (string, required —
city name or "lat,lon" coordinates) and `units` (string, optional — "metric"
or "imperial", defaults to "metric").

## Output
Returns a JSON object with `current` (temperature, condition, wind) and
`forecast` (array of daily summaries for the next 7 days).

---
name: weather-lookup
description: Fetches current weather conditions and a 7-day forecast for any location.
script: index.js
language: javascript
install: bun install
---

## When to use
Use for any question about current or upcoming weather at a specific place.
Not suitable for historical weather data.

## Input
Receives a JSON object via stdin:
- `location` (string, required): City name (e.g. "London") or "lat,lon" coordinates.
- `units` (string, optional): "metric" (Celsius/km·h) or "imperial" (Fahrenheit/mph). Defaults to "metric".
- Requires vault secret `openweather_api_key` (injected as SKILL_SECRET_OPENWEATHER_API_KEY).

// Parameters delivered as JSON via stdin
const params   = JSON.parse(await new Response(process.stdin).text());
const location = params.location;
const units    = params.units ?? "metric";

// Secrets injected from vault as SKILL_SECRET_{NAME_UPPER}
const apiKey = process.env.SKILL_SECRET_OPENWEATHER_API_KEY;

if (!location) {
  console.error("Missing required parameter: location");
  process.exit(1);
}

async function run() {
  // Geocode if location is not already coordinates
  const coords = await resolveCoords(location, apiKey);

  const url = `https://api.openweathermap.org/data/3.0/onecall?`
    + `lat=${coords.lat}&lon=${coords.lon}`
    + `&units=${units}&exclude=minutely,hourly,alerts`
    + `&appid=${apiKey}`;

  const res  = await fetch(url);
  if (!res.ok) throw new Error(`API error: ${res.status}`);
  const data = await res.json();

  const result = {
    location: coords.name,
    current: {
      temp:      data.current.temp,
      feels_like: data.current.feels_like,
      humidity:  data.current.humidity,
      wind_speed: data.current.wind_speed,
      condition: data.current.weather[0].description,
    },
    forecast: data.daily.slice(0, 7).map(d => ({
      date:      new Date(d.dt * 1000).toISOString().slice(0, 10),
      high:      d.temp.max,
      low:       d.temp.min,
      condition: d.weather[0].description,
      rain_mm:   d.rain ?? 0,
    })),
  };

  // Write JSON to stdout — ScalyClaw captures this as the skill result
  console.log(JSON.stringify(result, null, 2));
}

async function resolveCoords(loc, key) {
  if (/^-?\d+\.?\d*,-?\d+\.?\d*$/.test(loc)) {
    const [lat, lon] = loc.split(",").map(Number);
    return { lat, lon, name: loc };
  }
  const geoUrl = `https://api.openweathermap.org/geo/1.0/direct?q=${encodeURIComponent(loc)}&limit=1&appid=${key}`;
  const geo = await (await fetch(geoUrl)).json();
  if (!geo.length) throw new Error(`Location not found: ${loc}`);
  return { lat: geo[0].lat, lon: geo[0].lon, name: geo[0].name };
}

run().catch(err => {
  console.error(err.message);
  process.exit(1);
});

{
  "name": "weather-lookup",
  "type": "module"
}

---
name: text-analysis
description: Analyses text and returns readability scores, word frequency, and sentiment.
script: main.py
language: python
install: uv pip install -r requirements.txt
---

## When to use
Use when the user wants to understand the structure, reading level, or
sentiment of a document, email, article, or any chunk of text.

## Input
Receives a JSON object via stdin:
- `text` (string, required): The text to analyse. UTF-8, up to ~50,000 characters.
- `top_words` (number, optional): How many top words to include. Defaults to 10.

## Output
JSON with `readability` (Flesch–Kincaid grade and ease scores),
`sentiment` (positive/negative/neutral + score), and `top_words` (list
of word + count pairs).

import sys
import json
import os
from collections import Counter
import re

import textstat
from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer

# ScalyClaw writes the full parameter object to stdin as JSON
params = json.load(sys.stdin)
text      = params.get("text")
top_words = int(params.get("top_words", 10))

if not text:
    print(json.dumps({"error": "Missing required parameter: text"}))
    sys.exit(1)

# Readability
fk_grade = textstat.flesch_kincaid_grade(text)
fk_ease  = textstat.flesch_reading_ease(text)

# Sentiment (VADER works well on short to medium texts)
analyzer = SentimentIntensityAnalyzer()
scores   = analyzer.polarity_scores(text)
compound = scores["compound"]
sentiment = (
    "positive" if compound >= 0.05 else
    "negative" if compound <= -0.05 else
    "neutral"
)

# Word frequency (lowercased, stripped of punctuation)
words    = re.findall(r"\b[a-zA-Z]{3,}\b", text.lower())
stopwords = {"the", "and", "for", "that", "this", "with", "are", "was"}
words    = [w for w in words if w not in stopwords]
counter  = Counter(words)

result = {
    "readability": {
        "flesch_kincaid_grade": fk_grade,
        "flesch_reading_ease":  fk_ease,
        "grade_label": f"Grade {round(fk_grade)}",
    },
    "sentiment": {
        "label":   sentiment,
        "score":   compound,
        "detail":  scores,
    },
    "top_words": [
        {"word": w, "count": c}
        for w, c in counter.most_common(top_words)
    ],
    "word_count": len(words),
}

# Write JSON to stdout — ScalyClaw captures this as the skill result
print(json.dumps(result, indent=2))

textstat==0.7.3
vaderSentiment==3.3.2

---
name: system-info
description: Reports CPU load, memory usage, and disk space on the host machine.
script: run.sh
language: bash
---

## Input
Receives a JSON object via stdin:
- `disk_path` (string, optional): Filesystem path to check disk usage for. Defaults to "/".

#!/usr/bin/env bash
set -euo pipefail

# Parameters arrive as JSON on stdin — parse with jq
INPUT=$(cat)
DISK_PATH=$(echo "$INPUT" | jq -r '.disk_path // "/"')

# CPU load averages (1m, 5m, 15m)
LOAD=$(uptime | awk -F'load average:' '{print $2}' | xargs)

# Memory (Linux-compatible)
MEM_TOTAL=$(awk '/MemTotal/ {print $2}' /proc/meminfo 2>/dev/null || sysctl -n hw.memsize)
MEM_FREE=$(awk '/MemAvailable/ {print $2}' /proc/meminfo 2>/dev/null || vm_stat | awk '/Pages free/ {print $3}')

# Disk usage for requested path
DISK=$(df -h "$DISK_PATH" | awk 'NR==2 {printf "%s used of %s (%s)", $3, $2, $5}')

# Emit JSON to stdout
printf '{"load_average": "%s", "disk": "%s"}\n' "$LOAD" "$DISK"

# Copy a skill folder into the skills directory
cp -r ~/my-skills/weather-lookup ~/.scalyclaw/skills/

# ScalyClaw detects the new folder and publishes the reload signal automatically.
# You can also trigger reload manually:
redis-cli PUBLISH scalyclaw:skills:reload ""

// How ScalyClaw reloads skills on pub/sub signal (simplified)
subscriber.on("message", async (channel) => {
  if (channel === "scalyclaw:skills:reload") {
    // Re-read all SKILL.md files from disk
    const skills = await loadAllSkillManifests("~/.scalyclaw/skills");

    // Update the in-memory registry used by the skill section of the system prompt
    skillRegistry.set(skills);

    // Next LLM call will include the updated skill list in the system prompt
    console.log(`[skills] Reloaded ${skills.length} skills`);
  }
});

// JavaScript — read stdin, parse JSON, write result to stdout
const params = JSON.parse(await new Response(process.stdin).text());
const { query, max_results = 5 } = params;
// ... do work ...
console.log(JSON.stringify({ results }));

import sys, json
params = json.load(sys.stdin)
query = params["query"]
max_results = params.get("max_results", 5)
# ... do work ...
print(json.dumps({"results": results}))

# Bash — read stdin, parse with jq
INPUT=$(cat)
QUERY=$(echo "$INPUT" | jq -r '.query')
MAX_RESULTS=$(echo "$INPUT" | jq -r '.max_results // 5')
# ... do work ...
printf '{"results": []}\n'

async function run() {
  // Emit progress lines — ScalyClaw forwards these to the AI in real time
  console.log("PROGRESS: Fetching data from source...");
  const rawData = await fetchData();

  console.log("PROGRESS: Processing 1,200 records...");
  const processed = await processRecords(rawData);

  console.log("PROGRESS: Generating report...");
  const report = buildReport(processed);

  // Final result — the last JSON object on stdout is the skill's return value
  console.log(JSON.stringify(report));
}

---
name: github-pr-summary
description: Fetches and summarises open pull requests from a GitHub repository.
script: index.js
language: javascript
install: bun install
---

## Input
Receives a JSON object via stdin:
- `repo` (string, required): GitHub repository in "owner/repo" format.
- `state` (string, optional): Filter PRs by state — "open", "closed", or "all". Defaults to "open".
- Requires vault secret `github_token` (injected as SKILL_SECRET_GITHUB_TOKEN).

// Parameters delivered as JSON via stdin
const params = JSON.parse(await new Response(process.stdin).text());
const repo  = params.repo;
const state = params.state ?? "open";

// Secret injected from vault — never hardcoded
const token = process.env.SKILL_SECRET_GITHUB_TOKEN;

const res = await fetch(
  `https://api.github.com/repos/${repo}/pulls?state=${state}&per_page=20`,
  { headers: { Authorization: `Bearer ${token}`, Accept: "application/vnd.github+json" } }
);

if (!res.ok) {
  console.error(`GitHub API error: ${res.status} ${res.statusText}`);
  process.exit(1);
}

const prs = await res.json();
const summary = prs.map(pr => ({
  number: pr.number,
  title:  pr.title,
  author: pr.user.login,
  created: pr.created_at.slice(0, 10),
  url:    pr.html_url,
}));

console.log(JSON.stringify({ count: summary.length, pull_requests: summary }, null, 2));