Jsonlogic

JsonLogic

A skill for work with JsonLogic.

JsonLogic is a small, portable format for expressing conditional logic as JSON.

The JsonLogic standard is the universal rule format and defines its semantics. A rule at this level is language-agnostic. See references/jsonlogic.md and references/operations.md.

A specific library is the code that executes JsonLogic in a particular language, such as json-logic-js for JavaScript or json-logic-rb for Ruby. Libraries can differ in the operations they support, as well as their API shape and error handling.

Running JsonLogic

Library

If a specific implementation is named, such as json-logic-js, use that exact implementation. A language name alone, such as “in Python”, means use the library for that language from references/libraries.md. If neither a library nor a language is named, default to scripts/jsonlogic.rb.

Support

A rule can be valid JsonLogic and still be unsupported by the selected library or its current version. Flag unsupported operations. Never rewrite a valid JsonLogic rule just because one library can't run it. Say which level the limitation is at and offer the real options:

• a custom operation
• a different library if operation is not supported in specific implementation
• logic change

Playground artifact

Whenever a concrete rule is in play (created, explained, fixed, or executed), render it live instead of only describing it in text: seed assets/playground.html with that rule and data, then publish it with the Artifact tool. This runs under whoever installed the skill — each publish call creates the artifact under that person's own account, so it works the same way for every installer with no sharing step needed. The artifact is private by default, and publishing here just updates the same URL, so there's no separate decision to check on each time.

Two files, one static and one templated: assets/jsonlogic-core.js is the JsonLogic interpreter — it never changes between invocations, so publish it once per conversation (via the Artifact tool's files param) and never again. assets/playground.html is the thin page with the placeholders below; it's the only one that gets re-templated and republished on every change.

1. Read assets/playground.html. It's a fixed-design page (rule, live result, data) — never hand-edit its CSS/layout; only the placeholders below change per invocation.
2. Replace __INITIAL_RULE__ and __INITIAL_DATA__ with the rule/data objects, each as a JS/JSON literal (the output of JSON.stringify(...), valid to drop in as-is). No concrete rule yet → leave both untouched, the template falls back to a built-in default.
3. Replace __CURRENT_LANG_MODE__ with "ruby" when the target language is Ruby, otherwise "jsonlogic" (every other language shown here follows JsonLogic's own truthy/falsy rules; only Ruby's diverge). No language decided yet → leave it untouched, falls back to "jsonlogic".
4. Replace __VERIFY_LIB_LABEL__ with the same library Running JsonLogic → Library (above) resolved to for this task — this is what the page's "Verify in chat" button names when asking to confirm against the real implementation, so it must match, not default to Ruby just because that's this file's own fallback:
   • Ruby → "json-logic-rb (scripts/jsonlogic.rb)"
   • JavaScript / TypeScript → "json-logic-js"
   • Python → "maykin-json-logic-py"
   • Java → "json-logic-java"
   • PHP → "json-logic-php (jwadhams/json-logic-php)"
   • Go → "diegoholiveira/jsonlogic"
   • C# / .NET → "JsonLogic (json-everything)"
   • Any other language from references/libraries.md → that library's name as given there. No language/library decided yet → leave it untouched, falls back to Ruby's "json-logic-rb (scripts/jsonlogic.rb)", matching this skill's own default.
5. Write the result to a working file and publish it — the first time in a conversation: Artifact tool, action:"publish", that file's path, title:"JSON Logic Playground", icon:"code", plus files:{"jsonlogic-core.js":"assets/jsonlogic-core.js"} so the interpreter ships alongside it unmodified.
6. Whenever the rule, data, or language changes later in the same conversation, redo steps 1–4 with the new values and publish again with the same file path and the same url — but omit files this time, since jsonlogic-core.js never changes and an omitted file is kept as-is. This updates the same artifact in place instead of creating a new one.

Skip this for requests that never produce a concrete rule (e.g. "what does missing do").

The user can edit the rule/data directly in the artifact to test things — that's the point, it recalculates live. Never republish over those manual edits. Only republish when the user asks for a new or changed rule/condition in chat.

Writing JsonLogic

Step 1: Get the data shape

Always ask how to get the data’s field names before creating a new rule. Present this as choice. Use the client’s structured question mechanism, such as buttons or a picker, when available. Otherwise, present the choices as plain text.

Question: "How should I get your data's field names?". Offer three options:

• Option Schema — "I'll paste a schema — JSON Schema, OpenAPI, whatever format."
• Option Sample data — "I'll paste a real JSON example."
• Option Just guess — "Infer field names from my description."

The dialog only picks the method. The actual answer still comes as a normal follow-up message, not inside the dialog itself.

Step 2: Build the expression

Write the rule using the field names from Step 1.

Before writing a new rule, check references/operations.md for the full supported list and examples/ for worked patterns. For real upstream test cases per operator, see references/tests/.