{
  "base_url": "https://tools.ofthemachine.com",
  "title": "tools ofthemachine",
  "description": "Level-0 tools -- single-file fraglets that run in pinned containers via fragletc -- organised into packs, one directory each, published as one Agent Skill per pack.",
  "version": "0.1.0",
  "generated": {
    "by": "process:tools/catalog/compile.py",
    "at": "2026-11-13T18:27:40Z"
  },
  "tags": {
    "computation": "A run is a pure function of its parameters -- no network, no clock -- so results are reproducible and memoizable.",
    "documents": "Consumes or produces a document file -- PDF, Markdown, LaTeX, HTML, Office.",
    "engineering": "Serves software work -- source code, structured data, token budgets, and the building of this catalog.",
    "internet": "Reaches out to the public internet -- URLs, search, the host's own address.",
    "media": "Consumes or produces images, diagrams, or memes.",
    "world": "The answer depends on the state of the world at run time -- weather, news, the sky, public trivia feeds."
  },
  "packs": [
    {
      "name": "astro",
      "title": "Astro",
      "description": "The sky over a place and date -- moon phase, sunrise and sunset -- computed, not fetched.",
      "tags": [
        "world"
      ],
      "tools": [
        "daylight",
        "moon-phase",
        "sun-times"
      ]
    },
    {
      "name": "catalog",
      "title": "Catalog",
      "description": "Build, check, publish, and depend on a catalog of fraglet tools -- compile packs into skills, validate the result, render its website, and vendor pinned tools into another repository.",
      "tags": [
        "engineering",
        "internet"
      ],
      "tools": [
        "compile",
        "site",
        "validate",
        "vendor"
      ]
    },
    {
      "name": "chart",
      "title": "Chart",
      "description": "Generate standalone SVG vector charts (bar, line, scatter, pie) from tabular data.",
      "tags": [
        "media",
        "computation"
      ],
      "tools": [
        "plot"
      ]
    },
    {
      "name": "cloudflare",
      "title": "Cloudflare",
      "description": "What a Cloudflare account is using, read with a read-only API token -- today's Worker requests against the daily quota, and where they come from; its traffic over 24 minutes, hours and days, charted and diagnosed.",
      "tags": [
        "engineering",
        "internet"
      ],
      "tools": [
        "latency",
        "traffic",
        "usage"
      ]
    },
    {
      "name": "code",
      "title": "Code",
      "description": "Source-code structure and analysis -- symbol outlines across 140+ languages.",
      "tags": [
        "engineering"
      ],
      "tools": [
        "symbol-outline"
      ]
    },
    {
      "name": "data",
      "title": "Data",
      "description": "Slice, filter, and reshape structured data with jq and SQL.",
      "tags": [
        "engineering",
        "computation"
      ],
      "tools": [
        "jq",
        "sql"
      ]
    },
    {
      "name": "diagram",
      "title": "Diagram",
      "description": "Render Graphviz DOT with any layout engine.",
      "tags": [
        "media"
      ],
      "tools": [
        "graphviz"
      ]
    },
    {
      "name": "doc",
      "title": "Doc",
      "description": "Render Markdown, bundles, and LaTeX to PDF; extract text and render pages from PDF and Office files.",
      "tags": [
        "documents"
      ],
      "tools": [
        "extract-text",
        "latex-to-pdf",
        "markdown-to-pdf",
        "pdf-to-images"
      ]
    },
    {
      "name": "github",
      "title": "GitHub",
      "description": "GitHub issues and events as data for issue-driven workflows -- the fields of an issue form, and whether an event's sender is an approver.",
      "tags": [
        "engineering"
      ],
      "tools": [
        "check-approver",
        "read-issue-form"
      ]
    },
    {
      "name": "home-automation",
      "title": "Home Automation",
      "description": "Control and query home-automation devices on the LAN -- starting with Roku's ECP remote-control API.",
      "tags": [
        "internet"
      ],
      "tools": [
        "hue-lights",
        "hue-set",
        "roku-apps",
        "roku-launch",
        "roku-play",
        "roku-press",
        "roku-status",
        "roku-type"
      ]
    },
    {
      "name": "image",
      "title": "Image",
      "description": "Resize, crop, convert, compress, and diff raster images.",
      "tags": [
        "media"
      ],
      "tools": [
        "chyron",
        "diff",
        "qr",
        "transform"
      ]
    },
    {
      "name": "llm",
      "title": "LLM",
      "description": "Text from language models (one provider per tool, the API key declared as a secret and the provider's host fixed; llm/local for a model server on this machine, no key) and llm/prompt, which composes what they read.",
      "tags": [
        "internet"
      ],
      "tools": [
        "cohere",
        "local",
        "prompt"
      ]
    },
    {
      "name": "math",
      "title": "Math",
      "description": "Small pure computations -- primality, Fibonacci.",
      "tags": [
        "computation"
      ],
      "tools": [
        "fibonacci",
        "is-prime"
      ]
    },
    {
      "name": "meme",
      "title": "Meme",
      "description": "Find meme templates and caption them, with meme-cli.",
      "tags": [
        "media"
      ],
      "tools": [
        "caption",
        "catalog",
        "list",
        "templates"
      ]
    },
    {
      "name": "net",
      "title": "Net",
      "description": "The host's place on the network -- its public IP address and where an IP address is.",
      "tags": [
        "internet"
      ],
      "tools": [
        "ip-location",
        "public-ip"
      ]
    },
    {
      "name": "news",
      "title": "News",
      "description": "Headlines from any RSS or Atom feed, BBC world news by default.",
      "tags": [
        "world"
      ],
      "tools": [
        "headlines"
      ]
    },
    {
      "name": "package",
      "title": "Package",
      "description": "Facts about published software packages -- versions, release dates, licenses, and dependencies from PyPI, npm, crates.io, and Docker Hub.",
      "tags": [
        "engineering",
        "internet"
      ],
      "tools": [
        "metadata"
      ]
    },
    {
      "name": "poem",
      "title": "Poem",
      "description": "Poems about any subject -- the prompts a language model (llm/*) writes one from, in a chosen form and voice.",
      "tags": [
        "computation"
      ],
      "tools": [
        "prompt"
      ]
    },
    {
      "name": "receipt",
      "title": "Receipt",
      "description": "Work with fragletc run receipts -- attest one against the script that ran, or typeset a bundle of them as a ledger that links each run's inputs to earlier outputs.",
      "tags": [
        "engineering",
        "computation"
      ],
      "tools": [
        "attest",
        "ledger"
      ]
    },
    {
      "name": "sheet",
      "title": "Sheet",
      "description": "Inspect, summarize, and convert spreadsheet workbooks (Excel XLSX, ODS).",
      "tags": [
        "documents",
        "engineering"
      ],
      "tools": [
        "convert",
        "inspect"
      ]
    },
    {
      "name": "token",
      "title": "Token",
      "description": "Count and chunk text by LLM token budget (OpenAI tiktoken encodings).",
      "tags": [
        "engineering"
      ],
      "tools": [
        "chunk",
        "count"
      ]
    },
    {
      "name": "trivia",
      "title": "Trivia",
      "description": "Advice, cat facts, jokes, and on-this-day anniversaries from free public APIs.",
      "tags": [
        "world"
      ],
      "tools": [
        "advice",
        "cat-fact",
        "joke",
        "on-this-day"
      ]
    },
    {
      "name": "weather",
      "title": "Weather",
      "description": "Live current conditions and three-day forecasts for any place.",
      "tags": [
        "world"
      ],
      "tools": [
        "current",
        "forecast",
        "frog"
      ]
    },
    {
      "name": "web",
      "title": "Web",
      "description": "Search the web and turn a page into Markdown, PDF, a screenshot, or its metadata; find an existing archived snapshot.",
      "tags": [
        "internet",
        "documents"
      ],
      "tools": [
        "archive-snapshot",
        "page-metadata",
        "page-to-markdown",
        "page-to-pdf",
        "screenshot",
        "search",
        "wiki-summary"
      ]
    },
    {
      "name": "words",
      "title": "Words",
      "description": "Text games and transforms -- palindromes, ROT13, Wordle solving.",
      "tags": [
        "computation"
      ],
      "tools": [
        "is-palindrome",
        "rot13",
        "solve-wordle"
      ]
    }
  ],
  "tools": [
    {
      "pack": "astro",
      "stem": "daylight",
      "file": "daylight.py",
      "path": "astro/daylight.py",
      "description": "How light it is outside right now at a latitude and longitude, as one number from 0 (night) to 1 (the sun overhead): the sine of the sun's altitude, computed with ephem (no network). A body can grow by it.",
      "when": "Use when an agent's body or a card wants daylight now as a single number, e.g. a plant that opens in the sun.",
      "image": "ofthemachine/python3@sha256:59784cff1945b7d6093a591b5e5292b8c989f0691af0494fbbe1c6b8083a16cb",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "lat",
          "type": "string",
          "required": true,
          "default": null,
          "description": "Latitude in decimal degrees, e.g. 43.65"
        },
        {
          "name": "lon",
          "type": "string",
          "required": true,
          "default": null,
          "description": "Longitude in decimal degrees, east positive, e.g. -79.38"
        }
      ],
      "secrets": [],
      "outputs": [
        "light.txt"
      ],
      "procedure_hash": "sha256:e160efd0182c255cd3f8a211e284dc4a3447cd951fc222959766c70c7699fdc1",
      "id": "astro/daylight",
      "url": "https://tools.ofthemachine.com/astro/daylight.py",
      "usage": "daylight.py -p lat=\"<lat>\" -p lon=\"<lon>\" --output light.txt"
    },
    {
      "pack": "astro",
      "stem": "moon-phase",
      "file": "moon-phase.py",
      "path": "astro/moon-phase.py",
      "description": "The Moon's phase on a given UTC date, computed with ephem (no network): phase name, percent illuminated, and the dates of the next new and full moon. One line, ready for a dateline or an almanac box. The date is a parameter, never the clock, so the same inputs always give the same answer.",
      "when": "Use when the user asks what phase the moon is in or when the next full or new moon is, or an almanac, dateline, or caption needs the moon for a specific date.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "date",
          "type": "string",
          "required": true,
          "default": null,
          "description": "UTC date as YYYY-MM-DD"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:e6fbea037c04f6cd46dab37d9a7610d06bd72f88bee16cbd0d5c61adddcc1c95",
      "id": "astro/moon-phase",
      "url": "https://tools.ofthemachine.com/astro/moon-phase.py",
      "usage": "moon-phase.py -p date=\"<date>\""
    },
    {
      "pack": "astro",
      "stem": "sun-times",
      "file": "sun-times.py",
      "path": "astro/sun-times.py",
      "description": "Sunrise, sunset, and day length for a latitude, longitude, and UTC date, computed with ephem (no network). Times are printed in the given UTC offset so a caller can pass the local zone; the day-length delta against the day before says whether days are getting longer or shorter. Companion to net/ip-location.py, whose lat,lon this takes.",
      "when": "Use when the user asks when the sun rises or sets somewhere, how long the day is, or an almanac or weather box needs sun times for a place and date.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "lat",
          "type": "string",
          "required": true,
          "default": null,
          "description": "Latitude in decimal degrees, e.g. 53.5457"
        },
        {
          "name": "lon",
          "type": "string",
          "required": true,
          "default": null,
          "description": "Longitude in decimal degrees, east positive, e.g. -113.5"
        },
        {
          "name": "date",
          "type": "string",
          "required": true,
          "default": null,
          "description": "UTC date as YYYY-MM-DD"
        },
        {
          "name": "utc_offset",
          "type": "string",
          "required": false,
          "default": "0",
          "description": "Hours to add when printing times, e.g. -6 for Edmonton in September"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:2f1e6c670fe03aed6de089c4001a24c091797b2f3fbb4afb1a202e50c61bab38",
      "id": "astro/sun-times",
      "url": "https://tools.ofthemachine.com/astro/sun-times.py",
      "usage": "sun-times.py -p lat=\"<lat>\" -p lon=\"<lon>\" -p date=\"<date>\" [-p utc_offset=0]"
    },
    {
      "pack": "catalog",
      "stem": "compile",
      "file": "compile.py",
      "path": "catalog/compile.py",
      "description": "Compile a catalog of level-0 tools -- a tarball of pack directories, each an index.md plus fraglet files -- into its projections: one Agent Skill per pack (SKILL.md beside byte-identical copies of the tools), a Claude Code plugin per pack with a marketplace.json, llms.txt and llms-full.txt for agents arriving over HTTP, manifest.json with every tool's contract and procedure_hash, and an Open Knowledge Format bundle. Everything is derived from the tools' own headers and the pack index files; nothing is authored twice.",
      "when": "Use when the user asks to build, rebuild, or regenerate the tools catalog, or wants the skills, llms.txt, marketplace, or OKF views of a set of fraglet tools.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "archive",
          "type": "file",
          "required": true,
          "default": null,
          "description": "tar/tar.gz of the catalog source: index.md at the top level (optionally CONTRIBUTING.md beside it, copied through verbatim) plus one directory per pack (<pack>/index.md and the pack's tool files)"
        },
        {
          "name": "host",
          "type": "string",
          "required": false,
          "default": "tools.ofthemachine.com",
          "description": "Canonical host (served over https) where the catalog is published; OKF concepts locate computations by URL there, paired with procedure_hash"
        }
      ],
      "secrets": [],
      "outputs": [
        "tools.tar.gz"
      ],
      "procedure_hash": "sha256:4dd6cd2cadd8ab774d5148b8360c8d53dd46da4e1b2fd39793636e53fdf9e1bf",
      "id": "catalog/compile",
      "url": "https://tools.ofthemachine.com/catalog/compile.py",
      "usage": "compile.py -p archive=\"<archive>\" [-p host=tools.ofthemachine.com] --output tools.tar.gz"
    },
    {
      "pack": "catalog",
      "stem": "site",
      "file": "site.py",
      "path": "catalog/site.py",
      "description": "Render a compiled tools catalog (archived) into a static website: the catalog itself served verbatim -- llms.txt, manifest.json, every pack's SKILL.md and every tool file at the same paths -- plus an HTML layer over it: an explorer of every tool with search, tag and pack filters, grid and table views and a dark/light theme; one page per pack; one page per tool with its contract, provenance, a curl one-liner and its full source. Relative links throughout, so the result works from a file:// URL as well as a web root.",
      "when": "Use when the user wants the browsable website for a tools catalog, or CI publishes tools.ofthemachine.com from a freshly built catalog.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "archive",
          "type": "file",
          "required": true,
          "default": null,
          "description": "tools.tar.gz as catalog/compile.py emits it (the site root is the catalog root)"
        },
        {
          "name": "host",
          "type": "string",
          "required": false,
          "default": "tools.ofthemachine.com",
          "description": "Canonical host (served over https), used in curl one-liners, canonical links, and the CNAME file"
        }
      ],
      "secrets": [],
      "outputs": [
        "site.tar.gz"
      ],
      "procedure_hash": "sha256:c95a899853466c46390831d49deee76ce11a161711645a39d33d6b4465e61c21",
      "id": "catalog/site",
      "url": "https://tools.ofthemachine.com/catalog/site.py",
      "usage": "site.py -p archive=\"<archive>\" [-p host=tools.ofthemachine.com] --output site.tar.gz"
    },
    {
      "pack": "catalog",
      "stem": "validate",
      "file": "validate.py",
      "path": "catalog/validate.py",
      "description": "Validate a compiled tools catalog (archived): every pack's SKILL.md against the agentskills.io specification using skills-ref, the spec's own reference validator; every tool file present, executable, and hashing to the procedure_hash manifest.json records for it; every llms.txt link resolving; marketplace.json plugins matching the pack directories; and, if an okf/ bundle is present, every concept typed and every relative link resolving. Prints one line per finding and a summary; exit 0 only when clean.",
      "when": "Use when the user asks whether a compiled catalog of packs is valid, as the catalog build's validation step, or before publishing a catalog.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "archive",
          "type": "file",
          "required": true,
          "default": null,
          "description": "tar/tar.gz/zip of a compiled catalog: <pack>/SKILL.md and tools, manifest.json, llms.txt, marketplace.json, optional okf/"
        },
        {
          "name": "strict",
          "type": "string",
          "required": false,
          "default": "true",
          "description": "Treat warnings (body over 500 lines) as failures when true"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:643dd65d7aa7f67a0695e89836a95e27e36f5a2aa2917e9418251598ff51950d",
      "id": "catalog/validate",
      "url": "https://tools.ofthemachine.com/catalog/validate.py",
      "usage": "validate.py -p archive=\"<archive>\" [-p strict=true]"
    },
    {
      "pack": "catalog",
      "stem": "vendor",
      "file": "vendor.py",
      "path": "catalog/vendor.py",
      "description": "Fetch the catalog tools a project depends on, verify each against its pinned procedure_hash, and pack them into vendor.tar.gz (executable, at their catalog paths, reproducible bytes). The lock file names where the tools are published (\"source https://tools.ofthemachine.com\") and lists one \"<pack>/<stem>.<ext> sha256:<hex>\" per line (# comments allowed); the hashes are what manifest.json and every receipt call procedure_hash. A file whose hash does not match is refused and nothing is written, so base_url may fetch from anywhere -- a mirror, or a local `make serve` -- without weakening the pin or changing the recorded source.",
      "when": "Use when bootstrapping a repository that runs catalog tools from its own Makefile or CI: turn its tools.lock into a verified vendor/ directory before running anything.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "lock",
          "type": "file",
          "required": true,
          "default": null,
          "description": "tools.lock: a \"source <url>\" line, then \"<pack>/<stem>.<ext> sha256:<hex>\" per line"
        },
        {
          "name": "base_url",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Fetch from here instead of the lock's source (a mirror, or http://host.docker.internal:8080); integrity comes from the hashes, not the host"
        }
      ],
      "secrets": [],
      "outputs": [
        "vendor.tar.gz"
      ],
      "procedure_hash": "sha256:fd181a86193e86aff190cd650ebbb704458f08f1d22d3acdd2cf73a037075af5",
      "id": "catalog/vendor",
      "url": "https://tools.ofthemachine.com/catalog/vendor.py",
      "usage": "vendor.py -p lock=\"<lock>\" [-p base_url=\"<base_url>\"] --output vendor.tar.gz"
    },
    {
      "pack": "chart",
      "stem": "plot",
      "file": "plot.py",
      "path": "chart/plot.py",
      "description": "Generate standalone SVG vector charts (bar, line, scatter, pie) from CSV or JSON data.",
      "when": "Use when the user wants to visualize data, plot metrics, create a chart, or generate an SVG graph from numbers.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "buffer",
      "params": [
        {
          "name": "data",
          "type": "file",
          "required": false,
          "default": null,
          "description": "CSV or JSON data file mounted at /input/data"
        },
        {
          "name": "data_text",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Inline CSV or JSON text (or pipe stdin)"
        },
        {
          "name": "type",
          "type": "string",
          "required": false,
          "default": "bar",
          "description": "Chart type: bar, line, scatter, pie"
        },
        {
          "name": "title",
          "type": "string",
          "required": false,
          "default": "",
          "description": "Chart title displayed at the top"
        },
        {
          "name": "x",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Field name or 1-indexed column for X axis / labels"
        },
        {
          "name": "y",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Field name or 1-indexed column for Y axis / values"
        },
        {
          "name": "width",
          "type": "string",
          "required": false,
          "default": "800",
          "description": "SVG viewport width in pixels"
        },
        {
          "name": "height",
          "type": "string",
          "required": false,
          "default": "500",
          "description": "SVG viewport height in pixels"
        }
      ],
      "secrets": [],
      "outputs": [
        "chart.svg"
      ],
      "procedure_hash": "sha256:f9d86ed88c2cfdbee4857d8b68c2aebc302dea8c94174c479ecb8f81d46e3c72",
      "id": "chart/plot",
      "url": "https://tools.ofthemachine.com/chart/plot.py",
      "usage": "plot.py [-p data=\"<data>\"] [-p data_text=\"<data_text>\"] [-p type=bar] [-p title=] [-p x=\"<x>\"] [-p y=\"<y>\"] [-p width=800] [-p height=500] --output chart.svg"
    },
    {
      "pack": "cloudflare",
      "stem": "latency",
      "file": "latency.py",
      "path": "cloudflare/latency.py",
      "description": "How fast a Cloudflare site's origin answers, path by path: requests, p50/p95/p99 and size over the last 24 hours, against the last hour and the 24 hours before, flagging a real slowdown. An address making most of a window's requests is left out of it and named, so a flood cannot skew the numbers. Long polls are labelled and never flagged: their time is waiting. Read-only.",
      "when": "Use when someone asks how fast a Cloudflare site is answering, which path is slow, or whether a change made it faster or slower; for how much traffic and from whom, use cloudflare/traffic.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "zone",
          "type": "string",
          "required": true,
          "default": null,
          "description": "The zone (domain) to read, e.g. example.com"
        },
        {
          "name": "longpoll",
          "type": "string",
          "required": false,
          "default": "",
          "description": "Comma-separated paths that wait for news by design, e.g. /v1/since"
        },
        {
          "name": "top",
          "type": "string",
          "required": false,
          "default": "12",
          "description": "How many paths to list"
        }
      ],
      "secrets": [
        {
          "name": "CLOUDFLARE_API_TOKEN",
          "description": "A Cloudflare API token with Zone Analytics read and Zone read (read-only)"
        }
      ],
      "outputs": [
        "report.md"
      ],
      "procedure_hash": "sha256:a408ae463146802579e77ae5edde748b04db35f0a0a33babe5f17a610fac83f3",
      "id": "cloudflare/latency",
      "url": "https://tools.ofthemachine.com/cloudflare/latency.py",
      "usage": "latency.py -p zone=\"<zone>\" [-p longpoll=] [-p top=12] --output report.md"
    },
    {
      "pack": "cloudflare",
      "stem": "traffic",
      "file": "traffic.py",
      "path": "cloudflare/traffic.py",
      "description": "A Cloudflare zone's traffic over the last 24 minutes, 24 hours and 24 days, drawn and diagnosed: traffic.svg stacks the three as small multiples (requests from clients by status class, the daily Worker quota and today's projection on the days), worker.svg is the Worker's CPU time per hour against the free plan's 10 ms limit, and report.md is a Markdown report (a headline, the golden signals against the 24 hours before, the top talkers by kind of client and path, and diagnostics that name a poller, the side a 5xx came from, CPU headroom and the quota's pace). Clients are counted by kind (a browser by name, else a program). Read-only; cloudflare/usage is the quota alone, as gauges. It names the top client addresses, with country and client.",
      "when": "Use when someone asks what traffic a Cloudflare site or Worker is getting, for a chart of its requests over minutes, hours or days, why it returns errors, who is driving its request count, or how close it is to the daily Workers quota.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "zone",
          "type": "string",
          "required": true,
          "default": null,
          "description": "The zone (domain) to read, e.g. example.com"
        },
        {
          "name": "quota",
          "type": "string",
          "required": false,
          "default": "100000",
          "description": "Worker requests a day the plan allows (the free plan: 100000)"
        },
        {
          "name": "tz",
          "type": "string",
          "required": false,
          "default": "UTC",
          "description": "The IANA time zone the charts' times are shown in (the quota's day is always UTC's)"
        },
        {
          "name": "top",
          "type": "string",
          "required": false,
          "default": "5",
          "description": "How many top talkers and top addresses to list"
        }
      ],
      "secrets": [
        {
          "name": "CLOUDFLARE_API_TOKEN",
          "description": "A Cloudflare API token with Account Analytics read and Zone read (read-only)"
        }
      ],
      "outputs": [
        "traffic.svg",
        "worker.svg",
        "report.md"
      ],
      "procedure_hash": "sha256:21268ba90b36c46b6044760842fa5d0f78526a1ff2a1cb38e6362df600ed088d",
      "id": "cloudflare/traffic",
      "url": "https://tools.ofthemachine.com/cloudflare/traffic.py",
      "usage": "traffic.py -p zone=\"<zone>\" [-p quota=100000] [-p tz=UTC] [-p top=5] --output traffic.svg"
    },
    {
      "pack": "cloudflare",
      "stem": "usage",
      "file": "usage.py",
      "path": "cloudflare/usage.py",
      "description": "A zone's Worker requests today (the UTC day Cloudflare's daily quota counts) against that quota: how many so far, where the day ends if the last hour's rate holds, and the share of the quota that is, by Worker script; then the last hour's requests to the zone by path and by kind of client (a browser by name, else a program), never by address. The gauges are files (used.txt, projected.txt, share.txt, the projected share as a fraction) and stdout is a short report. Read-only: the token needs only Analytics read and Zone read.",
      "when": "Use when someone asks how close a Cloudflare Workers site is to its daily request limit, what is driving its request count, or whether a client is polling too hard.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "zone",
          "type": "string",
          "required": true,
          "default": null,
          "description": "The zone (domain) whose Workers to read, e.g. example.com"
        },
        {
          "name": "quota",
          "type": "string",
          "required": false,
          "default": "100000",
          "description": "Worker requests a day the plan allows (the free plan: 100000)"
        },
        {
          "name": "top",
          "type": "string",
          "required": false,
          "default": "8",
          "description": "How many paths and clients to list"
        }
      ],
      "secrets": [
        {
          "name": "CLOUDFLARE_API_TOKEN",
          "description": "A Cloudflare API token with Account Analytics read and Zone read (read-only)"
        }
      ],
      "outputs": [
        "used.txt",
        "projected.txt",
        "share.txt"
      ],
      "procedure_hash": "sha256:953e82a7741529c12a43cb860608684249507ce5325ed1fe2013a387aae06d1f",
      "id": "cloudflare/usage",
      "url": "https://tools.ofthemachine.com/cloudflare/usage.py",
      "usage": "usage.py -p zone=\"<zone>\" [-p quota=100000] [-p top=8] --output used.txt"
    },
    {
      "pack": "code",
      "stem": "symbol-outline",
      "file": "symbol-outline.py",
      "path": "code/symbol-outline.py",
      "description": "Extract compact hierarchical polyglot symbol outlines (classes, interfaces, functions, methods, structs) from source code across 140+ languages using Universal Ctags, omitting implementation bodies for up to 95% token savings.",
      "when": "Use when the user wants the structure of a source file or codebase (classes, functions, signatures) without reading whole files, or before planning edits across large files.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "code_source",
          "type": "file",
          "required": true,
          "default": null,
          "description": "Source file mounted at /input/code_source"
        },
        {
          "name": "file_path",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Original host path, used only for its extension (e.g. pkg/x.go)"
        },
        {
          "name": "file_ext",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Explicit extension override (py, .go, rs)"
        },
        {
          "name": "language",
          "type": "string",
          "required": false,
          "default": null,
          "description": "ctags language name for --language-force, or a short extension"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:4db44ac7156ce8acd11701126f6df4442196354eed1382f5d9dfd3b2a0b1e83e",
      "id": "code/symbol-outline",
      "url": "https://tools.ofthemachine.com/code/symbol-outline.py",
      "usage": "symbol-outline.py -p code_source=\"<code_source>\" [-p file_path=\"<file_path>\"] [-p file_ext=\"<file_ext>\"] [-p language=\"<language>\"]"
    },
    {
      "pack": "data",
      "stem": "jq",
      "file": "jq.py",
      "path": "data/jq.py",
      "description": "Slice, transform, filter, and extract JSON data using jq query expressions on JSON text or JSON files.",
      "when": "Use when the user wants to filter, reshape, or pull fields out of JSON, or an API payload needs trimming before it enters context.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "buffer",
      "params": [
        {
          "name": "filter",
          "type": "string",
          "required": true,
          "default": null,
          "description": "jq filter expression, e.g. .items[].name"
        },
        {
          "name": "json_source",
          "type": "file",
          "required": false,
          "default": null,
          "description": "Host JSON file mounted at /input/json_source"
        },
        {
          "name": "json_text",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Inline JSON text (or pipe stdin)"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:fae52da25dfdf89ac4d3a99c48cb7c7aef03a674c3f2dac5eef5d5b4e5190820",
      "id": "data/jq",
      "url": "https://tools.ofthemachine.com/data/jq.py",
      "usage": "jq.py -p filter=\"<filter>\" [-p json_source=\"<json_source>\"] [-p json_text=\"<json_text>\"]"
    },
    {
      "pack": "data",
      "stem": "sql",
      "file": "sql.py",
      "path": "data/sql.py",
      "description": "Run SQL queries on CSV, TSV, or tabular data, outputting results as Markdown, JSON, or CSV.",
      "when": "Use when the user wants to query, filter, aggregate, or slice tabular CSV or TSV data with SQL, or large tabular files must be summarized before entering context.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "buffer",
      "params": [
        {
          "name": "query",
          "type": "string",
          "required": true,
          "default": null,
          "description": "SQL query to run against the table named 'data' (e.g. 'SELECT status, count(*) FROM data GROUP BY status')"
        },
        {
          "name": "table_source",
          "type": "file",
          "required": false,
          "default": null,
          "description": "Host CSV/TSV file mounted at /input/table_source"
        },
        {
          "name": "table_text",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Inline CSV/TSV text (or pipe stdin)"
        },
        {
          "name": "delimiter",
          "type": "string",
          "required": false,
          "default": "auto",
          "description": "Column delimiter: auto, comma, tab, pipe, semicolon"
        },
        {
          "name": "format",
          "type": "string",
          "required": false,
          "default": "markdown",
          "description": "Output format: markdown, json, csv"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:f957077b5e66031de53b9c249661a42586fbb8f7b91be298256343e90ba91d62",
      "id": "data/sql",
      "url": "https://tools.ofthemachine.com/data/sql.py",
      "usage": "sql.py -p query=\"<query>\" [-p table_source=\"<table_source>\"] [-p table_text=\"<table_text>\"] [-p delimiter=auto] [-p format=markdown]"
    },
    {
      "pack": "diagram",
      "stem": "graphviz",
      "file": "graphviz.py",
      "path": "diagram/graphviz.py",
      "description": "Render Graphviz DOT source into an SVG, PNG, PDF, or JSON diagram. Choose a layout engine with engine=dot for hierarchies, neato or fdp for spring layouts, circo for cyclic structures, twopi for radial trees, or sfdp for large graphs. Source comes from the dot parameter, a dot_source file, or stdin, so a model can write the graph and this tool renders it deterministically.",
      "when": "Use when the user has Graphviz DOT source, or wants a graph, tree, flowchart, or network drawn from a description that maps to DOT.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "buffer",
      "params": [
        {
          "name": "dot",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Inline DOT source (or pipe stdin)"
        },
        {
          "name": "dot_source",
          "type": "file",
          "required": false,
          "default": null,
          "description": "Host DOT file mounted at /input/dot_source"
        },
        {
          "name": "engine",
          "type": "string",
          "required": false,
          "default": "dot",
          "description": "Layout engine (dot, neato, fdp, circo, twopi, sfdp, \u2026)"
        },
        {
          "name": "format",
          "type": "string",
          "required": false,
          "default": "svg",
          "description": "Output format (svg, png, pdf, json, \u2026)"
        }
      ],
      "secrets": [],
      "outputs": [
        "diagram"
      ],
      "procedure_hash": "sha256:4df3f83cb2527f6996862702a844088e322ac7f4d98b020411f8eda6fcccc627",
      "id": "diagram/graphviz",
      "url": "https://tools.ofthemachine.com/diagram/graphviz.py",
      "usage": "graphviz.py [-p dot=\"<dot>\"] [-p dot_source=\"<dot_source>\"] [-p engine=dot] [-p format=svg] --output diagram"
    },
    {
      "pack": "doc",
      "stem": "extract-text",
      "file": "extract-text.py",
      "path": "doc/extract-text.py",
      "description": "Extract readable text out of PDF, DOCX, PPTX, XLSX, ODT, RTF, HTML, and plain-text documents into structured Markdown carrying page, slide, and sheet markers. The format is detected from file content, so no extension is needed; pages selects a 1-indexed subset such as \"1-5\" or \"2,4,7-9\" (PDF pages, PPTX slides, XLSX sheets).",
      "when": "Use when the user wants the text of a PDF, Word, PowerPoint, Excel, ODT, RTF, or HTML file, or a document's page count.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "document",
          "type": "file",
          "required": true,
          "default": null,
          "description": "Document mounted at /input/document; format sniffed from content"
        },
        {
          "name": "pages",
          "type": "string",
          "required": false,
          "default": null,
          "description": "1-indexed subset like 1-5 or 2,4,7-9 (pages, slides, or sheets)"
        },
        {
          "name": "format",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Force a format instead of sniffing: pdf, docx, pptx, xlsx, odt, rtf, html, text"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:ae2e153ac9ca69b5ffb4f303043855fe29fe71cada34d7f588452627ea2257af",
      "id": "doc/extract-text",
      "url": "https://tools.ofthemachine.com/doc/extract-text.py",
      "usage": "extract-text.py -p document=\"<document>\" [-p pages=\"<pages>\"] [-p format=\"<format>\"]"
    },
    {
      "pack": "doc",
      "stem": "latex-to-pdf",
      "file": "latex-to-pdf.sh",
      "path": "doc/latex-to-pdf.sh",
      "description": "Compile a LaTeX document to PDF (full TeX Live, offline, deterministic -- no runtime package fetching). Mounts input TeX file via fragletc file-shaped param (:file) to /input/tex_source.",
      "when": "Use when the user has LaTeX source and wants the compiled PDF.",
      "image": "ofthemachine/latex@sha256:add4f310e2fb92ebeeb7bc7fa5a95f920fa78adabcc8565301bbb178eac2a0b3",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "tex_source",
          "type": "file",
          "required": true,
          "default": null,
          "description": "TeX source mounted at /input/tex_source"
        },
        {
          "name": "engine",
          "type": "string",
          "required": false,
          "default": "pdflatex",
          "description": "TeX engine: pdflatex, xelatex, or lualatex"
        }
      ],
      "secrets": [],
      "outputs": [
        "paper.pdf"
      ],
      "procedure_hash": "sha256:622b336d2bfb0c768489d11f83120619576f95d1882a5ce46cbd83a51122c052",
      "id": "doc/latex-to-pdf",
      "url": "https://tools.ofthemachine.com/doc/latex-to-pdf.sh",
      "usage": "latex-to-pdf.sh -p tex_source=\"<tex_source>\" [-p engine=pdflatex] --output paper.pdf"
    },
    {
      "pack": "doc",
      "stem": "markdown-to-pdf",
      "file": "markdown-to-pdf.py",
      "path": "doc/markdown-to-pdf.py",
      "description": "Render Markdown to one PDF with headless Chromium: inline text, a single .md (or .html) file, or a tar/tar.gz/zip bundle of pages plus the images and fonts they reference by relative path. Several pages become one document with page breaks (ordered by manifest.txt/order.txt when present, else by path) and a table of contents. style=reader applies clean reader typography; style=none renders the page exactly as authored, adding only the page box -- for pages that bring their own <style>, like newspapers, posters, and one-sheets.",
      "when": "Use when the user wants a PDF of some Markdown -- one note, a folder of documents compiled into a digest, or a designed page with its own assets and styling.",
      "image": "ofthemachine/headless-browser@sha256:8ac6f2f481f40e32a0b2f8dd7a834fd03197b1556bd8f55b1f167cd71d4877b0",
      "network": "none",
      "stdin": "buffer",
      "params": [
        {
          "name": "source",
          "type": "file",
          "required": false,
          "default": null,
          "description": "A .md or .html file, or a tar/tar.gz/zip bundle of pages and their assets"
        },
        {
          "name": "text",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Inline Markdown (or pipe stdin), when there is no source file"
        },
        {
          "name": "page",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Render only this entry of a bundle (e.g. index.html); omitted, every .md in the bundle"
        },
        {
          "name": "style",
          "type": "string",
          "required": false,
          "default": "reader",
          "description": "reader (house typography) or none (the page exactly as authored, plus the page box)"
        },
        {
          "name": "toc",
          "type": "string",
          "required": false,
          "default": "auto",
          "description": "Table of contents: auto (when there is more than one page), true, or false"
        },
        {
          "name": "title",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Document title, shown as a heading above the contents (reader style only)"
        },
        {
          "name": "size",
          "type": "string",
          "required": false,
          "default": "A4",
          "description": "Paper size (A4, Letter, ...)"
        },
        {
          "name": "margin",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Page margin on all sides (default 18mm for reader, 12mm for none)"
        }
      ],
      "secrets": [],
      "outputs": [
        "document.pdf"
      ],
      "procedure_hash": "sha256:8921a19d73692007cd2e35ec8edd09136d5c460e4f08f9579045c26f558e3139",
      "id": "doc/markdown-to-pdf",
      "url": "https://tools.ofthemachine.com/doc/markdown-to-pdf.py",
      "usage": "markdown-to-pdf.py [-p source=\"<source>\"] [-p text=\"<text>\"] [-p page=\"<page>\"] [-p style=reader] [-p toc=auto] [-p title=\"<title>\"] [-p size=A4] [-p margin=\"<margin>\"] --output document.pdf"
    },
    {
      "pack": "doc",
      "stem": "pdf-to-images",
      "file": "pdf-to-images.py",
      "path": "doc/pdf-to-images.py",
      "description": "Render PDF pages to high-resolution PNG images for visual inspection, slide viewing, or multimodal agent review.",
      "when": "Use when the user wants to see the visual layout of a PDF, inspect slides or figures, or convert PDF pages to PNG images.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "pdf_source",
          "type": "file",
          "required": true,
          "default": null,
          "description": "PDF file mounted at /input/pdf_source"
        },
        {
          "name": "page",
          "type": "string",
          "required": false,
          "default": "1",
          "description": "1-indexed page number to render to page.png, or 'all' to bundle every page into pages.tar.gz"
        },
        {
          "name": "scale",
          "type": "string",
          "required": false,
          "default": "2.0",
          "description": "Render scale factor (1.0 = 72 dpi, 2.0 = 144 dpi, 3.0 = 216 dpi)"
        }
      ],
      "secrets": [],
      "outputs": [
        "page.png",
        "pages.tar.gz"
      ],
      "procedure_hash": "sha256:fd0dd94dffd8319aecdc9a4d23d27bef2ca7cdb4cba0c946c9b403a58f94143f",
      "id": "doc/pdf-to-images",
      "url": "https://tools.ofthemachine.com/doc/pdf-to-images.py",
      "usage": "pdf-to-images.py -p pdf_source=\"<pdf_source>\" [-p page=1] [-p scale=2.0] --output page.png"
    },
    {
      "pack": "github",
      "stem": "check-approver",
      "file": "check-approver.py",
      "path": "github/check-approver.py",
      "description": "Whether a GitHub event's sender is an approver -- one of the people allowed to say \"go\" to an automated action -- printed as one line naming who approved what, or a failure giving the reason. The approvers file lists one GitHub username per line (# comments; a leading @ or \"- \" is ignored, so a plain YAML list also works); matching ignores case. label=<name> also requires the event to be that label being applied, so only that label counts as approval. Its receipt is the approval record: which event, which list, which answer.",
      "when": "Use when an issue-driven workflow must act only on approval from specific people -- e.g. before generating anything for a labelled issue, check that whoever applied the label is one of the repository's approvers.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "event",
          "type": "file",
          "required": true,
          "default": null,
          "description": "GitHub event JSON, e.g. $GITHUB_EVENT_PATH for an issues.labeled event"
        },
        {
          "name": "approvers",
          "type": "file",
          "required": true,
          "default": null,
          "description": "The approvers: one GitHub username per line, # comments allowed"
        },
        {
          "name": "label",
          "type": "string",
          "required": false,
          "default": null,
          "description": "If set, the event must be this label being applied (e.g. poem:ready)"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:53fd8a4b1fe5398db692b3b568e01ed9bbdc85c94c9d9118bf1a82bf51460f83",
      "id": "github/check-approver",
      "url": "https://tools.ofthemachine.com/github/check-approver.py",
      "usage": "check-approver.py -p event=\"<event>\" -p approvers=\"<approvers>\" [-p label=\"<label>\"]"
    },
    {
      "pack": "github",
      "stem": "read-issue-form",
      "file": "read-issue-form.py",
      "path": "github/read-issue-form.py",
      "description": "The fields of a GitHub issue form as JSON: {\"issue\": {number, title, author, url, labels}, \"fields\": {<label_slug>: value}}. GitHub renders a form submission as \"### Label\" headings with values beneath; each heading becomes a snake_case key, \"_No response_\" becomes null, and checkbox lists become arrays of the checked options. Accepts a whole GitHub event payload (issues/issue_comment, e.g. $GITHUB_EVENT_PATH) or a bare issue body.",
      "when": "Use when an issue-driven workflow needs the answers from a templated GitHub issue as structured data, e.g. turning a labelled request issue into a request.json for the next step.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "issue",
          "type": "file",
          "required": true,
          "default": null,
          "description": "GitHub event JSON (with .issue) or a bare issue body in Markdown"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:cbdcd0a65d008f251f380822c171a8fdcc6ba48857843ed782974d52a6eae5d0",
      "id": "github/read-issue-form",
      "url": "https://tools.ofthemachine.com/github/read-issue-form.py",
      "usage": "read-issue-form.py -p issue=\"<issue>\""
    },
    {
      "pack": "home-automation",
      "stem": "hue-lights",
      "file": "hue-lights.py",
      "path": "home-automation/hue-lights.py",
      "description": "List the lights on a Philips Hue bridge via its local v1 API -- one \"id\\tname\\ton\\tbri%\\treachable\\thex\" line per light. hex is the bulb's color as #rrggbb at full brightness (brightness stays in its own column), or \"-\" when the bulb has no color. hs mode is the inverse of hue-set's hex encoding, so a hex this prints can be sent back.",
      "when": "Use when the user asks what lights exist, their names/ids, or whether a light is on, reachable, at what brightness, and what color.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "ip",
          "type": "string",
          "required": true,
          "default": null,
          "description": "LAN IP address of the Hue bridge, e.g. 192.168.0.245"
        }
      ],
      "secrets": [
        {
          "name": "HUE_USER",
          "description": "Hue API username from link-button pairing (export HUE_USER on the agent host; delivered as a file, never a param, so it stays out of chat and the ledger)"
        }
      ],
      "outputs": [],
      "procedure_hash": "sha256:c00a4c41bf5055b59fac5d4af1f7bd0565e6e106b14ade1827ff718255c75cb9",
      "id": "home-automation/hue-lights",
      "url": "https://tools.ofthemachine.com/home-automation/hue-lights.py",
      "usage": "hue-lights.py -p ip=\"<ip>\""
    },
    {
      "pack": "home-automation",
      "stem": "hue-set",
      "file": "hue-set.py",
      "path": "home-automation/hue-set.py",
      "description": "Set a Philips Hue light (or all lights) via the bridge's local v1 API -- on/off/toggle, brightness percent, white temperature (kelvin or mired), color by hue degrees + saturation percent or by hex (e.g. hex=#ff8000). Light by numeric id or by name (exact then substring match, like home-automation/roku-launch.py); id=all drives group 0. Pairs with home-automation/hue-lights.py for discovery.",
      "when": "Use when the user asks to turn a light on or off, dim/brighten, or change its color or warmth -- e.g. \"turn off the kitchen\", \"dim living room to 30\", \"warm the bedroom\".",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "ip",
          "type": "string",
          "required": true,
          "default": null,
          "description": "LAN IP address of the Hue bridge, e.g. 192.168.0.245"
        },
        {
          "name": "id",
          "type": "string",
          "required": true,
          "default": null,
          "description": "Numeric light id, light name (e.g. \"kitchen\"), or \"all\" for every light"
        },
        {
          "name": "on",
          "type": "string",
          "required": false,
          "default": null,
          "description": "on, off, or toggle (toggle reads current state first; for \"all\", any-on means all-off)"
        },
        {
          "name": "bri",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Brightness 0-100 percent (0 turns the light off)"
        },
        {
          "name": "temp",
          "type": "string",
          "required": false,
          "default": null,
          "description": "White point in kelvin, e.g. 2700 warm / 4000 neutral / 6500 daylight (mutually exclusive with ct)"
        },
        {
          "name": "ct",
          "type": "string",
          "required": false,
          "default": null,
          "description": "White point in mired, 153-500 (Hue-native; mutually exclusive with temp)"
        },
        {
          "name": "hue",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Color hue in degrees 0-360 (needs a color-capable bulb)"
        },
        {
          "name": "sat",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Color saturation 0-100 percent (pairs with hue)"
        },
        {
          "name": "hex",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Hex color like #ff8000 or ff8000 (3 or 6 digits, # optional); shorthand for hue+sat, mutually exclusive with them"
        },
        {
          "name": "transition",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Fade time in seconds (Hue transitiontime is deciseconds; default bridge 0.4s)"
        },
        {
          "name": "name",
          "type": "string",
          "required": false,
          "default": null,
          "description": "New name for the light on the bridge (e.g. name=\"Living room\"; id=all refused)"
        },
        {
          "name": "delete",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Set true to DELETE this light from the bridge (numeric id only -- names and all refused; irreversible)"
        }
      ],
      "secrets": [
        {
          "name": "HUE_USER",
          "description": "Hue API username from link-button pairing (export HUE_USER on the agent host; delivered as a file, never a param, so it stays out of chat and the ledger)"
        }
      ],
      "outputs": [],
      "procedure_hash": "sha256:bbc1abfc22c04f36d4b6eae98cd08a66e0fcf6f93ede43777fe911f48dd4b3f8",
      "id": "home-automation/hue-set",
      "url": "https://tools.ofthemachine.com/home-automation/hue-set.py",
      "usage": "hue-set.py -p ip=\"<ip>\" -p id=\"<id>\" [-p on=\"<on>\"] [-p bri=\"<bri>\"] [-p temp=\"<temp>\"] [-p ct=\"<ct>\"] [-p hue=\"<hue>\"] [-p sat=\"<sat>\"] [-p hex=\"<hex>\"] [-p transition=\"<transition>\"] [-p name=\"<name>\"] [-p delete=\"<delete>\"]"
    },
    {
      "pack": "home-automation",
      "stem": "roku-apps",
      "file": "roku-apps.py",
      "path": "home-automation/roku-apps.py",
      "description": "List the apps installed on a Roku device via its ECP API -- one \"id\\tname\\tversion\" line per app, so a caller can find an app's numeric id for home-automation/roku-launch.py.",
      "when": "Use when the user asks what apps or channels are installed on a Roku, or needs an app's numeric id before launching it.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "ip",
          "type": "string",
          "required": true,
          "default": null,
          "description": "LAN IP address of the Roku, e.g. 192.168.0.73"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:5294f84b8527f784fda9146a4ec0ce4370e0ac6482e8f9d12e5f41f117883168",
      "id": "home-automation/roku-apps",
      "url": "https://tools.ofthemachine.com/home-automation/roku-apps.py",
      "usage": "roku-apps.py -p ip=\"<ip>\""
    },
    {
      "pack": "home-automation",
      "stem": "roku-launch",
      "file": "roku-launch.py",
      "path": "home-automation/roku-launch.py",
      "description": "Launch an app on a Roku device via its ECP API, optionally deep-linking straight into a piece of content when the app supports it (e.g. a Netflix title id) -- pairs with home-automation/roku-apps.py for the app_id.",
      "when": "Use when the user asks to open an app or channel on a Roku, or to jump straight to a specific show or movie inside one via a deep link.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "ip",
          "type": "string",
          "required": true,
          "default": null,
          "description": "LAN IP address of the Roku, e.g. 192.168.0.73"
        },
        {
          "name": "app_id",
          "type": "string",
          "required": true,
          "default": null,
          "description": "App name (e.g. Netflix, YouTube) or numeric app id from home-automation/roku-apps.py"
        },
        {
          "name": "content_id",
          "type": "string",
          "required": false,
          "default": null,
          "description": "App-specific content id to deep-link to (e.g. a Netflix title id from its netflix.com/title/<id> URL)"
        },
        {
          "name": "media_type",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Content type for the deep link, e.g. movie, series, episode"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:a212b44db1e8e500b5942f02e9471fd4514d195f789cc5e8fdea0abcf461a31e",
      "id": "home-automation/roku-launch",
      "url": "https://tools.ofthemachine.com/home-automation/roku-launch.py",
      "usage": "roku-launch.py -p ip=\"<ip>\" -p app_id=\"<app_id>\" [-p content_id=\"<content_id>\"] [-p media_type=\"<media_type>\"]"
    },
    {
      "pack": "home-automation",
      "stem": "roku-play",
      "file": "roku-play.py",
      "path": "home-automation/roku-play.py",
      "description": "Search Roku's on-device universal search for a title and play the Nth result -- Home to a known state, opens Search, types the query via Lit_ keys, arrows Right into the results grid, opens the chosen result, and presses Select to clear provider-choice/profile screens. NOTE: Roku sunset the /search/browse ECP endpoint in OS 12.0, so this deliberately drives the on-screen keyboard instead; and keypress/Enter is a documented no-op on the OS 15 search screen (focus stays parked on \"A\", so Select-after-Enter types a stray \"a\") -- do NOT re-add either. Live-verified 2026-10-03 on Roku Ultra OS 15.3.4 (Home, Down x6 to Search, type, Right x6 to result 1, Select opens result, Select picks provider -> playback); result_index beyond 1 extrapolates one more Right per position and is untested. Timing is fixed-delay and can be thrown off by slow app intro animations -- if playback doesn't start, a manual follow-up home-automation/roku-press.py -p key=Select is the fix, same as a human would do.",
      "when": "Use when the user names a show or movie to play on a Roku without saying which app -- e.g. \"play Seinfeld\" -- and wants Roku's own cross-provider search used to find and start it, rather than a specific app's deep link.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "ip",
          "type": "string",
          "required": true,
          "default": null,
          "description": "LAN IP address of the Roku, e.g. 192.168.0.73"
        },
        {
          "name": "query",
          "type": "string",
          "required": true,
          "default": null,
          "description": "Text to search for, e.g. \"stargate atlantis\""
        },
        {
          "name": "result_index",
          "type": "string",
          "required": false,
          "default": "1",
          "description": "Which result to open, counting from 1 (left to right in the results row). Only result_index=1 has been verified live; higher values extrapolate."
        },
        {
          "name": "confirm_selects",
          "type": "string",
          "required": false,
          "default": "1",
          "description": "How many times to press Select after opening the result, to clear a provider-choice and/or profile-picker screen. Some apps need a second Select that a slow intro animation can cause to land too early -- if it doesn't stick, send one more home-automation/roku-press.py -p key=Select by hand."
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:ee139c8a54be6a3b878af3e9bf415b5953ff6090e74130b5b078055e8ca39907",
      "id": "home-automation/roku-play",
      "url": "https://tools.ofthemachine.com/home-automation/roku-play.py",
      "usage": "roku-play.py -p ip=\"<ip>\" -p query=\"<query>\" [-p result_index=1] [-p confirm_selects=1]"
    },
    {
      "pack": "home-automation",
      "stem": "roku-press",
      "file": "roku-press.py",
      "path": "home-automation/roku-press.py",
      "description": "Send one or more remote-control key presses to a Roku device over its ECP API (no auth, LAN only) -- the same buttons as the physical remote: navigation, Select, Home, Back, playback, volume, channel. Pass a comma-separated list (e.g. \"Down,Down,Down,Select\") to send a whole sequence in one call instead of one fraglet run per key.",
      "when": "Use when the user asks to control a Roku -- press a remote button or a sequence of buttons, navigate menus, play/pause, change volume or channel, or go Home -- by its LAN IP address.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "ip",
          "type": "string",
          "required": true,
          "default": null,
          "description": "LAN IP address of the Roku, e.g. 192.168.0.73"
        },
        {
          "name": "key",
          "type": "string",
          "required": true,
          "default": null,
          "description": "One ECP key name, or a comma-separated sequence, e.g. \"Down,Down,Down,Select\". Keys: Home, Back, Select, Up, Down, Left, Right, Play, Rev, Fwd, InstantReplay, Info, Search, Enter, Backspace, VolumeUp, VolumeDown, VolumeMute, PowerOff, ChannelUp, ChannelDown"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:95379e161c346f4f000598c4833153e2f0e8546799e8b4ca20c3d4138596f5c4",
      "id": "home-automation/roku-press",
      "url": "https://tools.ofthemachine.com/home-automation/roku-press.py",
      "usage": "roku-press.py -p ip=\"<ip>\" -p key=\"<key>\""
    },
    {
      "pack": "home-automation",
      "stem": "roku-status",
      "file": "roku-status.py",
      "path": "home-automation/roku-status.py",
      "description": "Ask a Roku what it is doing right now via ECP queries -- the foreground app (query/active-app) plus player state/position/duration when the app reports them (query/media-player). Read-only: touches nothing on screen, safe to run mid-playback.",
      "when": "Use when the user asks what is playing, which app is open, or how far into something the Roku is -- or before a relaunch/resume, to record the app (and position, when available) to go back to.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "ip",
          "type": "string",
          "required": true,
          "default": null,
          "description": "LAN IP address of the Roku, e.g. 192.168.0.73"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:e2e68e702a1a7cb39275b872c86b228659f588ca4d1104184e5511fc938ac865",
      "id": "home-automation/roku-status",
      "url": "https://tools.ofthemachine.com/home-automation/roku-status.py",
      "usage": "roku-status.py -p ip=\"<ip>\""
    },
    {
      "pack": "home-automation",
      "stem": "roku-type",
      "file": "roku-type.py",
      "path": "home-automation/roku-type.py",
      "description": "Type free text into a Roku device's currently focused on-screen keyboard field (e.g. a search box) over its ECP API -- sends one keypress/Lit_<char> per character in a single call, instead of one fraglet run per letter. Pairs with home-automation/roku-press.py to navigate to the field first.",
      "when": "Use when the user asks to type a search query or other text into whatever on-screen text field is currently focused on a Roku.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "ip",
          "type": "string",
          "required": true,
          "default": null,
          "description": "LAN IP address of the Roku, e.g. 192.168.0.73"
        },
        {
          "name": "text",
          "type": "string",
          "required": true,
          "default": null,
          "description": "Text to type into the currently focused on-screen field, e.g. \"stargate atlantis\""
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:ab21dcf066f0c8ecbadabf42918ee754c373ad7b54c43efacf11733c9ab4df48",
      "id": "home-automation/roku-type",
      "url": "https://tools.ofthemachine.com/home-automation/roku-type.py",
      "usage": "roku-type.py -p ip=\"<ip>\" -p text=\"<text>\""
    },
    {
      "pack": "image",
      "stem": "chyron",
      "file": "chyron.py",
      "path": "image/chyron.py",
      "description": "Draw a TV-news lower third as a PNG: a studio backdrop, a red kicker box (BREAKING, LIVE, DEVELOPING), the headline bar, an optional ticker strip along the bottom, and the show's name as the corner bug. A still for a satirical or real broadcast; meme/caption puts text on a meme template instead.",
      "when": "Use when a news-style card, chyron, lower third or \"breaking news\" banner is wanted for a headline.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "headline",
          "type": "string",
          "required": true,
          "default": null,
          "description": "The headline across the bar, one line (long ones are shrunk, then cut with an ellipsis)"
        },
        {
          "name": "kicker",
          "type": "string",
          "required": false,
          "default": "BREAKING",
          "description": "The word in the red box before the headline, e.g. BREAKING, LIVE, DEVELOPING"
        },
        {
          "name": "ticker",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Text for the ticker strip along the bottom; empty: no ticker"
        },
        {
          "name": "show",
          "type": "string",
          "required": false,
          "default": "NEWS",
          "description": "The show's name, drawn as the corner bug"
        },
        {
          "name": "width",
          "type": "string",
          "required": false,
          "default": "1280",
          "description": "Image width in pixels (height is 9/16 of it)"
        },
        {
          "name": "mood",
          "type": "string",
          "required": false,
          "default": "on-air",
          "description": "How the anchor looks: on-air (composed), frazzled (hair up, tie loose, sweating) or beaming (a grin)"
        }
      ],
      "secrets": [],
      "outputs": [
        "chyron.png"
      ],
      "procedure_hash": "sha256:c2978495f118aa4b6265eaaf5d8f61129ab88cd570ac38cdd867de4f111be0a9",
      "id": "image/chyron",
      "url": "https://tools.ofthemachine.com/image/chyron.py",
      "usage": "chyron.py -p headline=\"<headline>\" [-p kicker=BREAKING] [-p ticker=\"<ticker>\"] [-p show=NEWS] [-p width=1280] [-p mood=on-air] --output chyron.png"
    },
    {
      "pack": "image",
      "stem": "diff",
      "file": "diff.py",
      "path": "image/diff.py",
      "description": "Compare two images pixel by pixel and report a machine-readable result (RESULT: IDENTICAL or RESULT: DIFFERENT) with the changed-pixel percentage, maximum channel delta, and bounding box of the change, alongside a PNG that tints every changed region red over the after image. Set tolerance to ignore per-channel noise below a 0-255 threshold, such as antialiasing jitter.",
      "when": "Use when the user wants to know whether two images differ, how much, and where -- visual regression checks, before/after comparisons.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "before",
          "type": "file",
          "required": true,
          "default": null,
          "description": "Baseline image"
        },
        {
          "name": "after",
          "type": "file",
          "required": true,
          "default": null,
          "description": "Comparison image"
        },
        {
          "name": "tolerance",
          "type": "string",
          "required": false,
          "default": "0",
          "description": "Ignore per-channel deltas below this 0-255 threshold"
        }
      ],
      "secrets": [],
      "outputs": [
        "diff.png"
      ],
      "procedure_hash": "sha256:ab52c15fd3cbb1bbd8dab38cb8c3fcc49cd6c8576fc0e34674026a98bf6a7bdb",
      "id": "image/diff",
      "url": "https://tools.ofthemachine.com/image/diff.py",
      "usage": "diff.py -p before=\"<before>\" -p after=\"<after>\" [-p tolerance=0] --output diff.png"
    },
    {
      "pack": "image",
      "stem": "qr",
      "file": "qr.py",
      "path": "image/qr.py",
      "description": "Make a QR code (PNG or SVG) for a link or any text, computed locally with segno and no network: what it encodes never leaves the container. Text that is a secret (an invite link, a Wi-Fi password) goes on stdin, not in text=: params are written into every receipt in plain text, stdin only as a hash. Prints the code's version and size, and with show=true the code itself, drawn in the terminal.",
      "when": "Use when the user wants a QR code, a scannable link, or a printable code for a URL, an invite, Wi-Fi details or any short text.",
      "image": "ofthemachine/python3@sha256:1a6a8e9cd91c93359794245e2a36b883ee54dfef06356ff8be1d4d863ee3823a",
      "network": "none",
      "stdin": "buffer",
      "params": [
        {
          "name": "text",
          "type": "string",
          "required": false,
          "default": null,
          "description": "What the code encodes (or pipe it on stdin, which a secret must use)"
        },
        {
          "name": "format",
          "type": "string",
          "required": false,
          "default": "png",
          "description": "png (raster) or svg (vector)"
        },
        {
          "name": "scale",
          "type": "string",
          "required": false,
          "default": "8",
          "description": "Pixels per module (the code's smallest square)"
        },
        {
          "name": "border",
          "type": "string",
          "required": false,
          "default": "4",
          "description": "Quiet zone around the code, in modules (scanners want 4)"
        },
        {
          "name": "error",
          "type": "string",
          "required": false,
          "default": "M",
          "description": "Error correction: L 7%, M 15%, Q 25%, H 30% of the code may be lost and still scan"
        },
        {
          "name": "show",
          "type": "string",
          "required": false,
          "default": "false",
          "description": "Also draw the code on stdout with text blocks, to scan from a terminal"
        }
      ],
      "secrets": [],
      "outputs": [
        "qr.png:optional",
        "qr.svg:optional"
      ],
      "procedure_hash": "sha256:2082c311e3391775ec7c9bacb86b7c8a6254d044f6861b3b00f524e390c590e2",
      "id": "image/qr",
      "url": "https://tools.ofthemachine.com/image/qr.py",
      "usage": "qr.py [-p text=\"<text>\"] [-p format=png] [-p scale=8] [-p border=4] [-p error=M] [-p show=false] --output qr.png:optional"
    },
    {
      "pack": "image",
      "stem": "transform",
      "file": "transform.py",
      "path": "image/transform.py",
      "description": "Resize, crop, convert, and compress images (PNG, JPEG, WebP, GIF, TIFF, BMP), reporting the byte savings on stdout. Set max_dimension to fit the longest edge inside a box while preserving aspect ratio, or give width and/or height directly; crop takes \"x,y,w,h\" in pixels and is applied before any resize. Shrinks oversized screenshots before they consume an agent's context or get embedded in a PDF.",
      "when": "Use when an image must be resized, cropped, converted to another format, or compressed to a smaller file size.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "image",
          "type": "file",
          "required": true,
          "default": null,
          "description": "Source image mounted at /input/image"
        },
        {
          "name": "max_dimension",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Fit longest edge inside this many pixels"
        },
        {
          "name": "width",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Target width in pixels"
        },
        {
          "name": "height",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Target height in pixels"
        },
        {
          "name": "crop",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Crop box as x,y,w,h in pixels (before resize)"
        },
        {
          "name": "format",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Output format (PNG, JPEG, WEBP, \u2026); default keeps source"
        },
        {
          "name": "quality",
          "type": "string",
          "required": false,
          "default": "85",
          "description": "JPEG/WebP quality 1-100"
        },
        {
          "name": "grayscale",
          "type": "string",
          "required": false,
          "default": "false",
          "description": "Convert to grayscale when true"
        }
      ],
      "secrets": [],
      "outputs": [
        "image"
      ],
      "procedure_hash": "sha256:66606990e1aec01379992222a56644b0e8c46f95effd1b4139783a07b3738e85",
      "id": "image/transform",
      "url": "https://tools.ofthemachine.com/image/transform.py",
      "usage": "transform.py -p image=\"<image>\" [-p max_dimension=\"<max_dimension>\"] [-p width=\"<width>\"] [-p height=\"<height>\"] [-p crop=\"<crop>\"] [-p format=\"<format>\"] [-p quality=85] [-p grayscale=false] --output image"
    },
    {
      "pack": "llm",
      "stem": "cohere",
      "file": "cohere.py",
      "path": "llm/cohere.py",
      "description": "One Cohere chat completion (api.cohere.com/v2/chat) from a prompt file or inline prompt, with an optional system prompt file, written to response.md. The host is fixed -- there is no base-URL parameter -- so the API key can only ever be sent to Cohere. seed makes sampling best-effort reproducible; stdout is a one-line summary (model, seed, tokens, finish reason), never the completion.",
      "when": "Use when a workflow step needs text generated by a language model -- a poem, a caption, a summary -- from a prompt file, and a Cohere API key (free trial keys work) is available.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "prompt",
          "type": "file",
          "required": false,
          "default": null,
          "description": "Prompt file (the user message)"
        },
        {
          "name": "prompt_text",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Inline prompt, when there is no prompt file"
        },
        {
          "name": "system",
          "type": "file",
          "required": false,
          "default": null,
          "description": "System prompt file"
        },
        {
          "name": "model",
          "type": "string",
          "required": false,
          "default": "command-a-03-2025",
          "description": "Cohere model id"
        },
        {
          "name": "temperature",
          "type": "string",
          "required": false,
          "default": "0.7",
          "description": "Sampling temperature, 0 to 1"
        },
        {
          "name": "seed",
          "type": "string",
          "required": false,
          "default": "42",
          "description": "Sampling seed; same seed and inputs give best-effort identical output"
        },
        {
          "name": "max_tokens",
          "type": "string",
          "required": false,
          "default": "1024",
          "description": "Maximum tokens to generate (a thinking model's thinking counts)"
        },
        {
          "name": "thinking_budget",
          "type": "string",
          "required": false,
          "default": null,
          "description": "For a thinking model (e.g. command-a-plus-05-2026): the most tokens it may think before answering, so the answer fits max_tokens; empty: the model's default"
        }
      ],
      "secrets": [
        {
          "name": "COHERE_API_KEY",
          "description": "Cohere API key (trial keys: 1,000 calls/month)"
        }
      ],
      "outputs": [
        "response.md"
      ],
      "procedure_hash": "sha256:b1c44eae8703887a6054929025928cfacd289a88aaf4b916a8bb63cf3eaa339d",
      "id": "llm/cohere",
      "url": "https://tools.ofthemachine.com/llm/cohere.py",
      "usage": "cohere.py [-p prompt=\"<prompt>\"] [-p prompt_text=\"<prompt_text>\"] [-p system=\"<system>\"] [-p model=command-a-03-2025] [-p temperature=0.7] [-p seed=42] [-p max_tokens=1024] [-p thinking_budget=\"<thinking_budget>\"] --output response.md"
    },
    {
      "pack": "llm",
      "stem": "local",
      "file": "local.py",
      "path": "llm/local.py",
      "description": "One chat completion from a local, OpenAI-compatible model server (LM Studio, llama.cpp, Ollama) from a prompt file and an optional system prompt file, written to response.md; no key. With think=false a reasoning model is asked to answer at once (an empty think block is prefilled), and any think block left in the answer is removed. stdout is a one-line summary, never the completion.",
      "when": "Use when a workflow step needs text from a language model running on this machine (LM Studio, llama.cpp, Ollama): no key, no cloud.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "prompt",
          "type": "file",
          "required": false,
          "default": null,
          "description": "Prompt file (the user message)"
        },
        {
          "name": "prompt_text",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Inline prompt, when there is no prompt file"
        },
        {
          "name": "system",
          "type": "file",
          "required": false,
          "default": null,
          "description": "System prompt file"
        },
        {
          "name": "model",
          "type": "string",
          "required": true,
          "default": null,
          "description": "The model's id on the server, e.g. qwen/qwen3.8-27b"
        },
        {
          "name": "endpoint",
          "type": "string",
          "required": false,
          "default": null,
          "description": "The server's chat completions URL as the container reaches it; empty: LM Studio on this machine (host.docker.internal, port 11234)"
        },
        {
          "name": "temperature",
          "type": "string",
          "required": false,
          "default": "0.7",
          "description": "Sampling temperature"
        },
        {
          "name": "seed",
          "type": "string",
          "required": false,
          "default": "42",
          "description": "Sampling seed"
        },
        {
          "name": "max_tokens",
          "type": "string",
          "required": false,
          "default": "400",
          "description": "Most tokens to generate"
        },
        {
          "name": "think",
          "type": "string",
          "required": false,
          "default": "false",
          "description": "Let a reasoning model think before it answers"
        },
        {
          "name": "timeout",
          "type": "string",
          "required": false,
          "default": "900",
          "description": "Seconds to wait for the answer: a local server may be busy with another agent's call, or loading the model"
        }
      ],
      "secrets": [],
      "outputs": [
        "response.md"
      ],
      "procedure_hash": "sha256:3dec4934f88e20a6e2ea6e9252c66d45483108fc856432f470f45243cb3a3431",
      "id": "llm/local",
      "url": "https://tools.ofthemachine.com/llm/local.py",
      "usage": "local.py [-p prompt=\"<prompt>\"] [-p prompt_text=\"<prompt_text>\"] [-p system=\"<system>\"] -p model=\"<model>\" [-p endpoint=\"<endpoint>\"] [-p temperature=0.7] [-p seed=42] [-p max_tokens=400] [-p think=false] [-p timeout=900] --output response.md"
    },
    {
      "pack": "llm",
      "stem": "prompt",
      "file": "prompt.py",
      "path": "llm/prompt.py",
      "description": "The two files an LLM step reads, for llm/cohere's prompt and system: prompt.md (the task, its subject, reference text, constraints) and system.md (the voice or house style, examples). Reference text and examples are length-capped and fenced as material, never instructions, so an earlier step's output (headlines, a transcript, a page) cannot rewrite the task. For poems, poem/prompt knows the forms.",
      "when": "Use as the step before llm/cohere when a request combines a task with text an earlier step produced or with a stored style guide, or whenever the prompt itself should be its own reproducible step.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "task",
          "type": "string",
          "required": true,
          "default": null,
          "description": "What the model must produce, in one or two sentences"
        },
        {
          "name": "subject",
          "type": "string",
          "required": false,
          "default": null,
          "description": "What it is about, with the concrete names, numbers and events to keep"
        },
        {
          "name": "context",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Reference text to work from, inline (often an earlier step's output); context_file for a file"
        },
        {
          "name": "context_file",
          "type": "file",
          "required": false,
          "default": null,
          "description": "Reference text to work from, as a file (e.g. news/headlines' headlines.md)"
        },
        {
          "name": "context_label",
          "type": "string",
          "required": false,
          "default": "Reference material",
          "description": "What the reference text is, named in prompt.md"
        },
        {
          "name": "constraints",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Hard requirements such as length, form or things to avoid; newline- or semicolon-separated"
        },
        {
          "name": "style",
          "type": "string",
          "required": false,
          "default": null,
          "description": "The voice or house style for system.md, inline; style_file for a file"
        },
        {
          "name": "style_file",
          "type": "file",
          "required": false,
          "default": null,
          "description": "The voice or house style for system.md, as a file"
        },
        {
          "name": "examples_file",
          "type": "file",
          "required": false,
          "default": null,
          "description": "Examples of the wanted output (their voice is borrowed, never their content)"
        }
      ],
      "secrets": [],
      "outputs": [
        "prompt.md",
        "system.md"
      ],
      "procedure_hash": "sha256:3c7190b37c30ed1f113cdfde78f4bfe6a596e244d4ff10c07304c9d387642a0f",
      "id": "llm/prompt",
      "url": "https://tools.ofthemachine.com/llm/prompt.py",
      "usage": "prompt.py -p task=\"<task>\" [-p subject=\"<subject>\"] [-p context=\"<context>\"] [-p context_file=\"<context_file>\"] [-p context_label=Reference material] [-p constraints=\"<constraints>\"] [-p style=\"<style>\"] [-p style_file=\"<style_file>\"] [-p examples_file=\"<examples_file>\"] --output prompt.md"
    },
    {
      "pack": "math",
      "stem": "fibonacci",
      "file": "fibonacci.py",
      "path": "math/fibonacci.py",
      "description": "The Nth Fibonacci number (0-indexed: F(0)=0, F(1)=1). Pure computation, no network.",
      "when": "Use when the user asks for a Fibonacci number by index.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "n",
          "type": "string",
          "required": true,
          "default": null,
          "description": "0-indexed position of the Fibonacci number to compute"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:fda98b6e5ff83936164a74f8463b970034e0b838406ee0e41027d72abcbc3de3",
      "id": "math/fibonacci",
      "url": "https://tools.ofthemachine.com/math/fibonacci.py",
      "usage": "fibonacci.py -p n=\"<n>\""
    },
    {
      "pack": "math",
      "stem": "is-prime",
      "file": "is-prime.py",
      "path": "math/is-prime.py",
      "description": "Check whether a number is prime, and show its smallest prime factor if not. Pure computation, no network.",
      "when": "Use when the user asks whether a number is prime or for its smallest factor.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "n",
          "type": "string",
          "required": true,
          "default": null,
          "description": "Integer to test for primality"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:5f53ce9a167214d6a6646be2fdc26967dbed499a1167bece04997d0c20ee22e5",
      "id": "math/is-prime",
      "url": "https://tools.ofthemachine.com/math/is-prime.py",
      "usage": "is-prime.py -p n=\"<n>\""
    },
    {
      "pack": "meme",
      "stem": "caption",
      "file": "caption.sh",
      "path": "meme/caption.sh",
      "description": "Render a caption onto a meme-cli template. lines is a single \"|\"-delimited string, one caption per box in order, whatever the box count -- a 1-box template is just \"one caption\", a 2-box is \"top|bottom\", an 8-box is \"a|b|c|d|e|f|g|h\". Run templates.sh show <id> first to check the real box count/order.",
      "when": "Use when the user wants a meme rendered from a known template with specific captions.",
      "image": "ofthemachine/meme@sha256:8a3ac29b110b9471e7688bf8d7bdc12fe83fd49da63a084a3db1a41549b6c57f",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "template",
          "type": "string",
          "required": true,
          "default": null,
          "description": "meme-cli template id (find with templates.sh search/show)"
        },
        {
          "name": "lines",
          "type": "string",
          "required": true,
          "default": null,
          "description": "Captions joined by |, one per box in template order"
        }
      ],
      "secrets": [],
      "outputs": [
        "meme.png"
      ],
      "procedure_hash": "sha256:d59b1f6500a589062af0b0f744ac3fc94f85b1d6640c1a44541042baa5e152af",
      "id": "meme/caption",
      "url": "https://tools.ofthemachine.com/meme/caption.sh",
      "usage": "caption.sh -p template=\"<template>\" -p lines=\"<lines>\" --output meme.png"
    },
    {
      "pack": "meme",
      "stem": "catalog",
      "file": "catalog.sh",
      "path": "meme/catalog.sh",
      "description": "Dump the whole meme catalog in one run: meme-cli list --json. Each template's alias is its id, its field count is the length of text_boxes, and its description is name. The image has no shell, so this is its own fraglet rather than a flag on templates.sh.",
      "when": "Use when a caller needs every template at once \u2014 alias, field count, description \u2014 to choose one.",
      "image": "ofthemachine/meme@sha256:8a3ac29b110b9471e7688bf8d7bdc12fe83fd49da63a084a3db1a41549b6c57f",
      "network": "none",
      "stdin": "none",
      "params": [],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:7b2c02b826e3209c5626f2ae829035828127045dbbb1af1912dd4b45f56bcffa",
      "id": "meme/catalog",
      "url": "https://tools.ofthemachine.com/meme/catalog.sh",
      "usage": "catalog.sh"
    },
    {
      "pack": "meme",
      "stem": "list",
      "file": "list.sh",
      "path": "meme/list.sh",
      "description": "Every meme template, one per line: its id, how many captions it takes (\"2 boxes\") and its name, in columns at least two spaces apart (meme-cli list). For keywords and box geometry, meme/catalog's JSON.",
      "when": "Use when a caller needs the template ids to choose from, as plain lines.",
      "image": "ofthemachine/meme@sha256:8a3ac29b110b9471e7688bf8d7bdc12fe83fd49da63a084a3db1a41549b6c57f",
      "network": "none",
      "stdin": "none",
      "params": [],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:5958ec8f5f030db832b97232274f65f1dc4a2675069bf81a08d3ddbe81450f65",
      "id": "meme/list",
      "url": "https://tools.ofthemachine.com/meme/list.sh",
      "usage": "list.sh"
    },
    {
      "pack": "meme",
      "stem": "templates",
      "file": "templates.sh",
      "path": "meme/templates.sh",
      "description": "Browse meme-cli's template library: templates.sh search <term>, templates.sh show <template> (boxes and their order), templates.sh list (popular templates), or templates.sh llms (meme-cli's guidance for LLMs). Arguments pass straight through to meme-cli; there are no -p parameters.",
      "when": "Use when the user wants to find a meme template, check a template's box count and order, list popular templates, or read meme-cli's guidance for LLMs.",
      "image": "ofthemachine/meme@sha256:8a3ac29b110b9471e7688bf8d7bdc12fe83fd49da63a084a3db1a41549b6c57f",
      "network": "none",
      "stdin": "none",
      "params": [],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:efb48fb11fccaab7dab0ebdd5c4697137b405f5c67f65e39894683505e791799",
      "id": "meme/templates",
      "url": "https://tools.ofthemachine.com/meme/templates.sh",
      "usage": "templates.sh"
    },
    {
      "pack": "net",
      "stem": "ip-location",
      "file": "ip-location.py",
      "path": "net/ip-location.py",
      "description": "Where an IP address is, from ip-api.com (no API key; its free tier is plain HTTP, so treat the answer as a hint, not a secret). Prints one line \"City, Region, Country (CC) lat,lon tz\" -- the City is the shape weather/current.py, weather/forecast.py and web/search.py take as their location. Pass ip= to look up a specific address; omitted, the caller's own public address is located.",
      "when": "Use when a workflow must find out where it is running (which city) before fetching local weather or news, or when the user asks where an IP address is.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "ip",
          "type": "string",
          "required": false,
          "default": null,
          "description": "IPv4 or IPv6 address to locate; omitted, the caller's own public address"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:51d26958a410a6a3037932f4c540458646661cd691c6b67a6b490896afc0916d",
      "id": "net/ip-location",
      "url": "https://tools.ofthemachine.com/net/ip-location.py",
      "usage": "ip-location.py [-p ip=\"<ip>\"]"
    },
    {
      "pack": "net",
      "stem": "public-ip",
      "file": "public-ip.py",
      "path": "net/public-ip.py",
      "description": "The host's public IPv4/IPv6 address as the internet sees it, from ifconfig.me (no API key) -- what `curl ifconfig.me` prints, as a fraglet so a workflow can record where it ran. Prints the bare address and nothing else.",
      "when": "Use when the user asks what their public IP is, or a workflow needs the address it is running from -- for example to locate itself with net/ip-location.py.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:d71f3629175b487624acc6086f2561641680b39c7f8cc34b2436e9f44f6c6396",
      "id": "net/public-ip",
      "url": "https://tools.ofthemachine.com/net/public-ip.py",
      "usage": "public-ip.py"
    },
    {
      "pack": "news",
      "stem": "headlines",
      "file": "headlines.py",
      "path": "news/headlines.py",
      "description": "The latest headlines from a news feed (RSS or Atom), newest first. Clean markdown list by default, or TSV when format=tsv.",
      "when": "Use when the user wants today's top news or the latest headlines from an outlet, section, or feed, or a briefing, caption, or prompt needs a live headline.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "feed",
          "type": "string",
          "required": false,
          "default": "feeds.bbci.co.uk/news/world/rss.xml",
          "description": "RSS or Atom feed URL (https:// is assumed when no scheme is given)"
        },
        {
          "name": "count",
          "type": "string",
          "required": false,
          "default": "5",
          "description": "How many headlines to print"
        },
        {
          "name": "format",
          "type": "string",
          "required": false,
          "default": "markdown",
          "description": "Stdout format: \"markdown\" for formatted clickable links, or \"tsv\" for title\\tlink\\tdate"
        }
      ],
      "secrets": [],
      "outputs": [
        "headlines.md:d=The headlines as the markdown list, whatever format stdout takes, for a later step to read"
      ],
      "procedure_hash": "sha256:420b5c9ae4ccfe5afaed87fe79ff6eb5ffb98d12c20cca03ed7fc07e038165d0",
      "id": "news/headlines",
      "url": "https://tools.ofthemachine.com/news/headlines.py",
      "usage": "headlines.py [-p feed=feeds.bbci.co.uk/news/world/rss.xml] [-p count=5] [-p format=markdown] --output headlines.md:d=The headlines as the markdown list, whatever format stdout takes, for a later step to read"
    },
    {
      "pack": "package",
      "stem": "metadata",
      "file": "metadata.py",
      "path": "package/metadata.py",
      "description": "Query package registries (pypi, npm, crates, dockerhub) for latest versions, release dates, licenses, and dependencies.",
      "when": "Use when the user wants to check package versions, verify dependency existence, check release dates, or inspect package metadata.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "registry",
          "type": "string",
          "required": true,
          "default": null,
          "description": "Registry ecosystem: pypi, npm, crates, dockerhub"
        },
        {
          "name": "package",
          "type": "string",
          "required": true,
          "default": null,
          "description": "Package or image name (e.g. 'requests', 'express', 'tokio', 'library/alpine')"
        },
        {
          "name": "version",
          "type": "string",
          "required": false,
          "default": "latest",
          "description": "Specific version tag to query, or 'latest'"
        },
        {
          "name": "format",
          "type": "string",
          "required": false,
          "default": "markdown",
          "description": "Output format: markdown or json"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:b9fbfd879e68fd814fd7302e317900026434607c181b3882f6359a8f8715d8a4",
      "id": "package/metadata",
      "url": "https://tools.ofthemachine.com/package/metadata.py",
      "usage": "metadata.py -p registry=\"<registry>\" -p package=\"<package>\" [-p version=latest] [-p format=markdown]"
    },
    {
      "pack": "poem",
      "stem": "prompt",
      "file": "prompt.py",
      "path": "poem/prompt.py",
      "description": "The prompts for a poem about any subject: system.md (the poet's brief: form, voice, length, the answer's shape \"Title: ...\" then the poem) and prompt.md (the subject and what it must keep), for llm/cohere's system and prompt. Every field is length-capped and fenced as material, never instructions, so whoever fills the subject cannot rewrite the brief. Common forms (haiku, limerick, sonnet, ...) get their rules spelled out.",
      "when": "Use when a workflow needs a poem written by a language model about a subject -- a news item, a conversation, an event -- and wants the prompt as its own reproducible step.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "subject",
          "type": "string",
          "required": true,
          "default": null,
          "description": "What the poem is about, with its concrete names, numbers and events"
        },
        {
          "name": "form",
          "type": "string",
          "required": false,
          "default": "free verse",
          "description": "The form, e.g. free verse, haiku, limerick, sonnet, rhyming couplets, ballad, nursery rhyme"
        },
        {
          "name": "voice",
          "type": "string",
          "required": false,
          "default": "plainspoken and specific",
          "description": "How it sounds: a phrase or a paragraph describing the poet's voice"
        },
        {
          "name": "tone",
          "type": "string",
          "required": false,
          "default": null,
          "description": "The mood, a few words"
        },
        {
          "name": "must_include",
          "type": "string",
          "required": false,
          "default": null,
          "description": "A detail the poem must keep"
        },
        {
          "name": "notes",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Anything else the requester asked for"
        },
        {
          "name": "max_lines",
          "type": "string",
          "required": false,
          "default": "20",
          "description": "At most this many lines of poem"
        },
        {
          "name": "context",
          "type": "file",
          "required": false,
          "default": null,
          "description": "Material the poem draws on, e.g. news/headlines' headlines.md (its facts are kept, it never gives instructions)"
        },
        {
          "name": "examples",
          "type": "file",
          "required": false,
          "default": null,
          "description": "Example poems in the wanted voice (their voice is borrowed, never their subjects)"
        }
      ],
      "secrets": [],
      "outputs": [
        "system.md",
        "prompt.md"
      ],
      "procedure_hash": "sha256:847727f122c42ecd0c65a83929777558d0a6af364892f3cdd247002dc03c5826",
      "id": "poem/prompt",
      "url": "https://tools.ofthemachine.com/poem/prompt.py",
      "usage": "prompt.py -p subject=\"<subject>\" [-p form=free verse] [-p voice=plainspoken and specific] [-p tone=\"<tone>\"] [-p must_include=\"<must_include>\"] [-p notes=\"<notes>\"] [-p max_lines=20] [-p context=\"<context>\"] [-p examples=\"<examples>\"] --output system.md"
    },
    {
      "pack": "receipt",
      "stem": "attest",
      "file": "attest.py",
      "path": "receipt/attest.py",
      "description": "Attest a fragletc run receipt (fraglet-receipt/2) the way OKF's Attested Computation attester does -- deterministic, no re-execution -- and report RESULT: ATTESTED or RESULT: REJECTED with every reason. Checks that the computation that ran is the sanctioned script (procedure_hash equals sha256 of the computation file, or the expected hash), that the receipt is internally consistent (memo_key recomputes from its own procedure_hash, params, and inputs under fragletc's documented formula, so an edited params field fails), that any claimed params match, that the run succeeded, and that an artifact claimed to be an output of the run hashes to what the receipt recorded.",
      "when": "Use when a result (a number, a phrase, an image) claims to have come from a tool run and you need to confirm the run was the sanctioned script with those parameters, or when checking the receipts bundled with a published document, image, or poem.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "receipt",
          "type": "file",
          "required": true,
          "default": null,
          "description": "The fragletc --receipt JSON to attest"
        },
        {
          "name": "computation",
          "type": "file",
          "required": false,
          "default": null,
          "description": "The sanctioned script the run must have executed (its sha256 must equal the receipt's procedure_hash)"
        },
        {
          "name": "procedure_hash",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Expected procedure_hash (sha256:<hex>), for when the script file is not at hand"
        },
        {
          "name": "params",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Claimed parameters as key=value pairs separated by |, e.g. location=Edmonton|day=0; each must match the receipt exactly"
        },
        {
          "name": "artifact",
          "type": "file",
          "required": false,
          "default": null,
          "description": "A file claimed to be one of the run's outputs (a figure, a document); its sha256 must appear in the receipt's outputs"
        },
        {
          "name": "artifact_name",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Which declared output the artifact claims to be (a relpath under /output); omitted, any output may match"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:56852e30c550552fe93d3bd3c0f8e4a894eee079b7d19ecb18e9e015d3b43a73",
      "id": "receipt/attest",
      "url": "https://tools.ofthemachine.com/receipt/attest.py",
      "usage": "attest.py -p receipt=\"<receipt>\" [-p computation=\"<computation>\"] [-p procedure_hash=\"<procedure_hash>\"] [-p params=\"<params>\"] [-p artifact=\"<artifact>\"] [-p artifact_name=\"<artifact_name>\"]"
    },
    {
      "pack": "receipt",
      "stem": "ledger",
      "file": "ledger.py",
      "path": "receipt/ledger.py",
      "description": "Typeset an archive of fragletc receipts (fraglet-receipt/2) as a ledger: one row per run with its tool, memo key, params, inputs and outputs by content hash, and exit code, in run order. Where a run's input hash is an earlier run's output hash the row says so, which makes the archive a provenance graph a reader can follow by hand. If the archive also carries blobs/<sha256 hex> files, every hash present in it is marked, so the reader knows which bytes travel with the ledger and which are hash-only. Emits an HTML fragment (default) or Markdown to stdout, for embedding in a page such as a Daily Fraglet edition.",
      "when": "Use when a bundle of receipts must be presented to a reader as evidence -- an appendix, a ledger page, a provenance table -- rather than handed over as raw JSON.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "receipts",
          "type": "file",
          "required": true,
          "default": null,
          "description": "tar/tar.gz/zip containing receipts/*.json and optionally blobs/<hex>"
        },
        {
          "name": "format",
          "type": "string",
          "required": false,
          "default": "html",
          "description": "html (a fragment with class=\"ledger\") or md"
        },
        {
          "name": "prefix",
          "type": "string",
          "required": false,
          "default": "12",
          "description": "How many hex characters of each hash to print"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:7a3706383ac7cde41ce5a50776ddf5ea7ed0c7e58e84cf209028dc59796fef68",
      "id": "receipt/ledger",
      "url": "https://tools.ofthemachine.com/receipt/ledger.py",
      "usage": "ledger.py -p receipts=\"<receipts>\" [-p format=html] [-p prefix=12]"
    },
    {
      "pack": "sheet",
      "stem": "convert",
      "file": "convert.py",
      "path": "sheet/convert.py",
      "description": "Convert a sheet from an Excel (XLSX) or ODS spreadsheet into clean CSV, TSV, or JSON.",
      "when": "Use when the user wants to extract data from an Excel or ODS workbook into a flat format (CSV, TSV, JSON) or save a sheet as a table.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "workbook",
          "type": "file",
          "required": true,
          "default": null,
          "description": "Spreadsheet workbook mounted at /input/workbook"
        },
        {
          "name": "sheet",
          "type": "string",
          "required": false,
          "default": "1",
          "description": "1-indexed sheet index or sheet name to convert (defaults to the first sheet)"
        },
        {
          "name": "format",
          "type": "string",
          "required": false,
          "default": "csv",
          "description": "Output format: csv, tsv, json"
        }
      ],
      "secrets": [],
      "outputs": [
        "sheet.csv",
        "sheet.tsv",
        "sheet.json"
      ],
      "procedure_hash": "sha256:b465760b47627d9e6c6e2ae7acc4d3a316312adf39722ab81bf8fc8fb70e5e03",
      "id": "sheet/convert",
      "url": "https://tools.ofthemachine.com/sheet/convert.py",
      "usage": "convert.py -p workbook=\"<workbook>\" [-p sheet=1] [-p format=csv] --output sheet.csv"
    },
    {
      "pack": "sheet",
      "stem": "inspect",
      "file": "inspect.py",
      "path": "sheet/inspect.py",
      "description": "Inspect spreadsheet workbooks (XLSX, ODS), listing sheet names, row and column dimensions, and header columns.",
      "when": "Use when the user wants to see the structure, sheets, dimensions, or column names of an Excel or ODS spreadsheet without reading all rows.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "workbook",
          "type": "file",
          "required": true,
          "default": null,
          "description": "Spreadsheet workbook mounted at /input/workbook"
        },
        {
          "name": "format",
          "type": "string",
          "required": false,
          "default": "markdown",
          "description": "Output format: markdown or json"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:78e22335f0414ecb2b33794512af5e34218a2c3d24a186a4d7823a8c1f2b05bb",
      "id": "sheet/inspect",
      "url": "https://tools.ofthemachine.com/sheet/inspect.py",
      "usage": "inspect.py -p workbook=\"<workbook>\" [-p format=markdown]"
    },
    {
      "pack": "token",
      "stem": "chunk",
      "file": "chunk.py",
      "path": "token/chunk.py",
      "description": "Split text into token-budgeted chunks using OpenAI tiktoken encodings, preferring paragraph boundaries and hard-splitting only paragraphs that exceed the budget on their own. Each chunk is introduced by a \"[chunk i/n tokens=k]\" marker line, and overlap carries that many tokens of tail context into the next chunk so meaning is not severed mid-thought. Companion to counter, which measures what this splits.",
      "when": "Use when text is too large for one prompt and must be split into token-budgeted pieces that respect paragraph boundaries.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "buffer",
      "params": [
        {
          "name": "text",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Inline text to chunk (or pipe stdin)"
        },
        {
          "name": "text_source",
          "type": "file",
          "required": false,
          "default": null,
          "description": "Host file mounted at /input/text_source"
        },
        {
          "name": "max_tokens",
          "type": "string",
          "required": false,
          "default": "1000",
          "description": "Token budget per chunk"
        },
        {
          "name": "overlap",
          "type": "string",
          "required": false,
          "default": "100",
          "description": "Tail tokens carried into the next chunk"
        },
        {
          "name": "encoding",
          "type": "string",
          "required": false,
          "default": "cl100k_base",
          "description": "tiktoken encoding or model name"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:6250f718ac5beb7d6ded8117d495e3f8ac7f66cd57a2733312a981704d5c3326",
      "id": "token/chunk",
      "url": "https://tools.ofthemachine.com/token/chunk.py",
      "usage": "chunk.py [-p text=\"<text>\"] [-p text_source=\"<text_source>\"] [-p max_tokens=1000] [-p overlap=100] [-p encoding=cl100k_base]"
    },
    {
      "pack": "token",
      "stem": "count",
      "file": "count.py",
      "path": "token/count.py",
      "description": "Calculate BPE token counts and token statistics for text or files using OpenAI tiktoken tokenizers (cl100k_base or o200k_base).",
      "when": "Use when the user asks how many tokens some text or file is, or a prompt must be checked against a token budget.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "buffer",
      "params": [
        {
          "name": "text",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Inline text to tokenize (or pipe stdin)"
        },
        {
          "name": "encoding",
          "type": "string",
          "required": false,
          "default": "cl100k_base",
          "description": "tiktoken encoding or model name"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:90e6dbca3fe1429ce2ecafa5990f78678791df5112c291917f73650b8b667923",
      "id": "token/count",
      "url": "https://tools.ofthemachine.com/token/count.py",
      "usage": "count.py [-p text=\"<text>\"] [-p encoding=cl100k_base]"
    },
    {
      "pack": "trivia",
      "stem": "advice",
      "file": "advice.py",
      "path": "trivia/advice.py",
      "description": "A random piece of advice (Advice Slip API, no API key).",
      "when": "Use when the user asks for a random piece of advice, or a caption or meme needs one.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:364e8075cc28bb20039912b22f7c8a29292c300a40b370f501d476507b43676d",
      "id": "trivia/advice",
      "url": "https://tools.ofthemachine.com/trivia/advice.py",
      "usage": "advice.py"
    },
    {
      "pack": "trivia",
      "stem": "cat-fact",
      "file": "cat-fact.py",
      "path": "trivia/cat-fact.py",
      "description": "A random cat fact (catfact.ninja, no API key).",
      "when": "Use when the user asks for a cat fact, or a caption or meme needs one.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:c2b1c14e8414a2d1edd2e81552a1de29d7a91c5a7bd7763aaed8d714359d8f31",
      "id": "trivia/cat-fact",
      "url": "https://tools.ofthemachine.com/trivia/cat-fact.py",
      "usage": "cat-fact.py"
    },
    {
      "pack": "trivia",
      "stem": "joke",
      "file": "joke.py",
      "path": "trivia/joke.py",
      "description": "Fetch a random humorous joke or one-liner (icanhazdadjoke.com, no API key).",
      "when": "Use when the user asks for a joke or one-liner, or a caption or meme needs one.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:79672dc55ca623a0c60e3940cf75e78a61595553682873a2cf9eee589408b48e",
      "id": "trivia/joke",
      "url": "https://tools.ofthemachine.com/trivia/joke.py",
      "usage": "joke.py"
    },
    {
      "pack": "trivia",
      "stem": "on-this-day",
      "file": "on-this-day.py",
      "path": "trivia/on-this-day.py",
      "description": "Notable events that happened on a month and day in history, from Wikipedia's \"On this day\" feed (Wikimedia API, no key). One \"YEAR<TAB>text\" line per event, most recent first, count-limited, so a briefing can pick the one that rhymes with today.",
      "when": "Use when the user asks what happened on this day in history, or a newspaper, briefing, or caption wants an anniversary for a given date.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "month",
          "type": "string",
          "required": true,
          "default": null,
          "description": "Month as a number, 1-12"
        },
        {
          "name": "day",
          "type": "string",
          "required": true,
          "default": null,
          "description": "Day of the month, 1-31"
        },
        {
          "name": "count",
          "type": "string",
          "required": false,
          "default": "8",
          "description": "How many events to print"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:28ecb7ef4d664cc658e7e4db5fa12acfe5b27e72002e5662e07b83cbfbb38115",
      "id": "trivia/on-this-day",
      "url": "https://tools.ofthemachine.com/trivia/on-this-day.py",
      "usage": "on-this-day.py -p month=\"<month>\" -p day=\"<day>\" [-p count=8]"
    },
    {
      "pack": "weather",
      "stem": "current",
      "file": "current.py",
      "path": "weather/current.py",
      "description": "Real current conditions for any city, via wttr.in's compact one-line format (%l: +%t %C) -- genuinely current, not a canned response. Outputs a single short phrase ready for captions or notifications, avoiding unrenderable emoji glyphs.",
      "when": "Use when the user asks what the weather is like right now somewhere, or a caption or notification needs a live conditions phrase.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "location",
          "type": "string",
          "required": true,
          "default": null,
          "description": "City, region, or landmark, e.g. Vancouver or Mount Fuji"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:1ecc17f9d6bfb2c1f608e2b8a0dbbbf92a0f0072f16e90de8b435e45d581cd4a",
      "id": "weather/current",
      "url": "https://tools.ofthemachine.com/weather/current.py",
      "usage": "current.py -p location=\"<location>\""
    },
    {
      "pack": "weather",
      "stem": "forecast",
      "file": "forecast.py",
      "path": "weather/forecast.py",
      "description": "Three-day weather forecast for a city, region, or landmark (Open-Meteo geocoding + forecast, no API key). Companion to weather/current.py, which only covers right now and takes the same location parameter. Pass day=0/1/2 to print just today, tomorrow, or day after; omitted prints all three days.",
      "when": "Use when the user asks about tomorrow's or the next few days' weather somewhere, or wants a planning-grade forecast rather than current conditions.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "location",
          "type": "string",
          "required": true,
          "default": null,
          "description": "City, region, or landmark, e.g. Vancouver or Mount Fuji"
        },
        {
          "name": "day",
          "type": "string",
          "required": false,
          "default": null,
          "description": "0 today, 1 tomorrow, 2 day after; omit for all three"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:a1adb8336f4e97729643f297be944c4b6aabc0877ea436e578f589165999a3a6",
      "id": "weather/forecast",
      "url": "https://tools.ofthemachine.com/weather/forecast.py",
      "usage": "forecast.py -p location=\"<location>\" [-p day=\"<day>\"]"
    },
    {
      "pack": "weather",
      "stem": "frog",
      "file": "frog.py",
      "path": "weather/frog.py",
      "description": "A weather frog (Wetterfrosch): how nice one day will be somewhere, as a rung on its ladder from 0 (stay in) to 1 (glorious), plus a one-line croak saying why and whether to take an umbrella, and the chance of rain (rain.txt, 0 to 1) a body can drink from. Open-Meteo, no API key. The rung is a number a body can climb by; the croak is what it says.",
      "when": "Use when an agent's body or a morning card wants the forecast as one number and one line rather than a table.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "location",
          "type": "string",
          "required": true,
          "default": null,
          "description": "City, region, or landmark, e.g. Toronto"
        },
        {
          "name": "day",
          "type": "string",
          "required": false,
          "default": "1",
          "description": "0 today, 1 tomorrow, 2 the day after"
        }
      ],
      "secrets": [],
      "outputs": [
        "rung.txt",
        "croak.txt",
        "rain.txt"
      ],
      "procedure_hash": "sha256:24622a9219807987efb005b0f1403a518f8f16472e777bf16ba32066d6457fdb",
      "id": "weather/frog",
      "url": "https://tools.ofthemachine.com/weather/frog.py",
      "usage": "frog.py -p location=\"<location>\" [-p day=1] --output rung.txt"
    },
    {
      "pack": "web",
      "stem": "archive-snapshot",
      "file": "archive-snapshot.py",
      "path": "web/archive-snapshot.py",
      "description": "Look up whether archive.ph already has a snapshot of a URL -- GET /newest/<url> and report its Location header on a redirect. Lookup only: never submits a new snapshot, so it can't be used to force-archive something that isn't already there. Prints nothing (not an error) when no snapshot exists -- the caller falls back to the original link.",
      "when": "Use when a link may be paywalled or gone and the user wants an existing archive.ph snapshot of it, without creating one.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "url",
          "type": "string",
          "required": true,
          "default": null,
          "description": "URL to look up on archive.ph"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:48f71510689a887cd27b9ab7b4b51755bc511a225dedac23fe76f05d854ed10d",
      "id": "web/archive-snapshot",
      "url": "https://tools.ofthemachine.com/web/archive-snapshot.py",
      "usage": "archive-snapshot.py -p url=\"<url>\""
    },
    {
      "pack": "web",
      "stem": "page-metadata",
      "file": "page-metadata.py",
      "path": "web/page-metadata.py",
      "description": "Fetch a URL and extract its <title> and Open Graph tags (og:title, og:description, og:image) -- stdlib html.parser only, no external service.",
      "when": "Use when the user wants a page's title, description, or preview image, or a link needs a caption without fetching the whole article.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "url",
          "type": "string",
          "required": true,
          "default": null,
          "description": "Page URL to fetch"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:f9c80667a89c716604fafc2d553dccb76bc12954da0930629607222e6b5b04b2",
      "id": "web/page-metadata",
      "url": "https://tools.ofthemachine.com/web/page-metadata.py",
      "usage": "page-metadata.py -p url=\"<url>\""
    },
    {
      "pack": "web",
      "stem": "page-to-markdown",
      "file": "page-to-markdown.py",
      "path": "web/page-to-markdown.py",
      "description": "Extract clean, readable Markdown article text from any web page using Trafilatura, stripping ads, navigations, sidebars, and boilerplate.",
      "when": "Use when the user wants the article text of a web page, or a page must be read without ads, navigation, and boilerplate.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "url",
          "type": "string",
          "required": true,
          "default": null,
          "description": "Page URL to extract"
        }
      ],
      "secrets": [],
      "outputs": [
        "article.md"
      ],
      "procedure_hash": "sha256:10dc2e8d27f66a33aeb7c7bc9ad59feef1d7c0d2450bbbbffa8bcdd22a7c8e18",
      "id": "web/page-to-markdown",
      "url": "https://tools.ofthemachine.com/web/page-to-markdown.py",
      "usage": "page-to-markdown.py -p url=\"<url>\" --output article.md"
    },
    {
      "pack": "web",
      "stem": "page-to-pdf",
      "file": "page-to-pdf.py",
      "path": "web/page-to-pdf.py",
      "description": "Render a webpage to a PDF (headless Chromium via Playwright) -- the print-to-PDF cousin of web/screenshot.py. Pass headers=<json object> to send extra request headers, as in web/screenshot.py.",
      "when": "Use when the user wants a PDF of a web page as the browser would print it, including layout and images.",
      "image": "ofthemachine/headless-browser@sha256:f79c496c6737113c0f6e2d648474a67fb1a416fa34c22220d5714d0b7c6a6036",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "url",
          "type": "string",
          "required": true,
          "default": null,
          "description": "Page URL to render"
        },
        {
          "name": "headers",
          "type": "string",
          "required": false,
          "default": null,
          "description": "JSON object of extra non-secret HTTP headers (e.g. Accept-Language); recorded in plaintext in receipts, so never credentials"
        }
      ],
      "secrets": [],
      "outputs": [
        "page.pdf"
      ],
      "procedure_hash": "sha256:e6c751e4af2b550620d30da2809fdf059802332f245d418bb4ec7dc5db2a7443",
      "id": "web/page-to-pdf",
      "url": "https://tools.ofthemachine.com/web/page-to-pdf.py",
      "usage": "page-to-pdf.py -p url=\"<url>\" [-p headers=\"<headers>\"] --output page.pdf"
    },
    {
      "pack": "web",
      "stem": "screenshot",
      "file": "screenshot.py",
      "path": "web/screenshot.py",
      "description": "Capture a full-page PNG screenshot of a webpage (headless Chromium via Playwright). Pass headers=<json object> to send extra request headers. settle_ms (default 2000) is an extra wait after page load, for pages whose real content only appears after their own async JS runs.",
      "when": "Use when the user wants a picture of a rendered page, or a visual check of a URL rather than its text.",
      "image": "ofthemachine/headless-browser@sha256:f79c496c6737113c0f6e2d648474a67fb1a416fa34c22220d5714d0b7c6a6036",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "url",
          "type": "string",
          "required": true,
          "default": null,
          "description": "Page URL to capture"
        },
        {
          "name": "headers",
          "type": "string",
          "required": false,
          "default": null,
          "description": "JSON object of extra non-secret HTTP headers (e.g. Accept-Language); recorded in plaintext in receipts, so never credentials"
        },
        {
          "name": "settle_ms",
          "type": "string",
          "required": false,
          "default": "2000",
          "description": "Extra wait after page load for async JS content"
        }
      ],
      "secrets": [],
      "outputs": [
        "page.png"
      ],
      "procedure_hash": "sha256:6f4177a6b183d233a0f6f9ba331b1df9983af8df7f0d6d13e704fbbcab146588",
      "id": "web/screenshot",
      "url": "https://tools.ofthemachine.com/web/screenshot.py",
      "usage": "screenshot.py -p url=\"<url>\" [-p headers=\"<headers>\"] [-p settle_ms=2000] --output page.png"
    },
    {
      "pack": "web",
      "stem": "search",
      "file": "search.py",
      "path": "web/search.py",
      "description": "Search the web through DuckDuckGo and print one \"title<TAB>url<TAB>snippet\" result per line, with no API key required. Set site to constrain results to a single domain, timelimit to d, w, m, or y for recency, and region for locale-weighted results. Pairs with page-to-markdown to turn a query into full article text.",
      "when": "Use when the user wants web search results, recent news about a topic or place, or pages from a specific site, and no API key is available.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "query",
          "type": "string",
          "required": true,
          "default": null,
          "description": "Search query"
        },
        {
          "name": "max_results",
          "type": "string",
          "required": false,
          "default": "10",
          "description": "Maximum results to print"
        },
        {
          "name": "site",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Restrict results to this domain"
        },
        {
          "name": "region",
          "type": "string",
          "required": false,
          "default": "wt-wt",
          "description": "DuckDuckGo region code (wt-wt = worldwide)"
        },
        {
          "name": "timelimit",
          "type": "string",
          "required": false,
          "default": null,
          "description": "Recency filter: d, w, m, or y"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:8113f4e62845ca7d37d7462184c8a931cc317d2578683b4d0b422f446910a453",
      "id": "web/search",
      "url": "https://tools.ofthemachine.com/web/search.py",
      "usage": "search.py -p query=\"<query>\" [-p max_results=10] [-p site=\"<site>\"] [-p region=wt-wt] [-p timelimit=\"<timelimit>\"]"
    },
    {
      "pack": "web",
      "stem": "wiki-summary",
      "file": "wiki-summary.py",
      "path": "web/wiki-summary.py",
      "description": "The lead summaries of the Wikipedia articles that best match one or more topics (Wikipedia's own search, then each article's page summary), written to summary.md as each article's title, link and a few paragraphs. Topics are separated by semicolons (cat behavior; object permanence) and share the byte budget. An article whose title shares no word with its topic is not taken (a search for a sentence finds noise), so a topic may find nothing; a query nothing matches still succeeds, and summary.md says no article was found, so a workflow that cites it goes on with no evidence rather than stopping. A rate limit or a server error exits 75 (temporary: fragletc --retry). Unlike web/page-to-markdown it needs no URL, only words.",
      "when": "Use when a workflow step needs encyclopedic background on subjects named in a few plain words -- a topic, a dish, a person -- as a file a later step reads. Name subjects, not sentences: \"cat behavior\", not \"cats who knock things off tables\".",
      "image": "ofthemachine/python3@sha256:59784cff1945b7d6093a591b5e5292b8c989f0691af0494fbbe1c6b8083a16cb",
      "network": "required",
      "stdin": "none",
      "params": [
        {
          "name": "query",
          "type": "string",
          "required": true,
          "default": null,
          "description": "What to look up: a topic in a few plain words, or several separated by semicolons, e.g. cat behavior; object permanence"
        },
        {
          "name": "language",
          "type": "string",
          "required": false,
          "default": "en",
          "description": "Wikipedia language code, e.g. en, fr, de"
        },
        {
          "name": "max_bytes",
          "type": "string",
          "required": false,
          "default": "3000",
          "description": "At most this many bytes of summary text in all, shared by the topics"
        }
      ],
      "secrets": [],
      "outputs": [
        "summary.md"
      ],
      "procedure_hash": "sha256:a8c7da326cbf24ff21f5663e3536b6e3190b8f7fa1a592419f494d3dc7d5f625",
      "id": "web/wiki-summary",
      "url": "https://tools.ofthemachine.com/web/wiki-summary.py",
      "usage": "wiki-summary.py -p query=\"<query>\" [-p language=en] [-p max_bytes=3000] --output summary.md"
    },
    {
      "pack": "words",
      "stem": "is-palindrome",
      "file": "is-palindrome.py",
      "path": "words/is-palindrome.py",
      "description": "Check whether text is a palindrome, ignoring case, spaces, and punctuation. Pure computation, no network.",
      "when": "Use when the user asks whether a word or phrase is a palindrome.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "text",
          "type": "string",
          "required": true,
          "default": null,
          "description": "Text to check"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:4eb8633759beea213209997e680d6da3d9511f1e98223c352d525feb26cc632b",
      "id": "words/is-palindrome",
      "url": "https://tools.ofthemachine.com/words/is-palindrome.py",
      "usage": "is-palindrome.py -p text=\"<text>\""
    },
    {
      "pack": "words",
      "stem": "rot13",
      "file": "rot13.py",
      "path": "words/rot13.py",
      "description": "ROT13 a string (its own inverse -- run it twice to get the original back). Pure computation, no network.",
      "when": "Use when the user asks to ROT13 encode or decode text.",
      "image": "ofthemachine/python3@sha256:a015b4f9f0e7c1648f8fcd4164f6a296dd3c9189404f88f333a9764d08d13522",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "text",
          "type": "string",
          "required": true,
          "default": null,
          "description": "Text to encode or decode"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:53693c507a4702661b2fc502abb50df69c91afc2d9f71d79112a48332855e98c",
      "id": "words/rot13",
      "url": "https://tools.ofthemachine.com/words/rot13.py",
      "usage": "rot13.py -p text=\"<text>\""
    },
    {
      "pack": "words",
      "stem": "solve-wordle",
      "file": "solve-wordle.java",
      "path": "words/solve-wordle.java",
      "description": "Filter possible 5-letter Wordle answers given one or more guess+feedback rounds, using 100hellos/java's real wordalytica fluent WordSet API and word list (not a reimplementation). clues is \"guess:result|guess:result|...\", each result a 5-char G/Y/X string matching that guess letter-for-letter (G=green/correct spot, Y=yellow/wrong spot, X=gray/absent), e.g. \"crane:GYXXX|mount:XXGXY\". Report the raw colors you see -- this tool does the Wordle-logic-to-predicate translation, not you.",
      "when": "Use when the user is solving a Wordle and reports the colours from one or more guesses.",
      "image": "100hellos/java@sha256:2b8b7b5817381f6d9460e2b4a124ad5f0ca01d668d4db084690a45939831b909",
      "network": "none",
      "stdin": "none",
      "params": [
        {
          "name": "clues",
          "type": "string",
          "required": true,
          "default": null,
          "description": "guess:result rounds joined by |; result is 5 chars of G/Y/X, e.g. crane:GYXXX|mount:XXGXY"
        }
      ],
      "secrets": [],
      "outputs": [],
      "procedure_hash": "sha256:6fedce72a5705432f332aa123528594b9ab6bc54041564536039052e8afe4138",
      "id": "words/solve-wordle",
      "url": "https://tools.ofthemachine.com/words/solve-wordle.java",
      "usage": "solve-wordle.java -p clues=\"<clues>\""
    }
  ]
}
