$ ~/registry/skill/facebook-llms-skills-pysa-json-models

SKILL

pysa-json-models

Name: pysa-json-models
Author: facebook

Read, write, and debug Pysa JSON taint models and .models output.

Stars

★ 7,174

Source

GitHub

Updated

2026-06-27

// securityCaution

Prompt only, no code
Open source

Summary

The material indicates this is essentially a prompt-only, open-source skill for interpreting/writing Pysa JSON model syntax. It requires no secrets, declares no remote endpoints, and shows no code execution or local data access capability; overall risk is low, with limited adoption and unclear maintenance as minor caveats.

CredentialsLow risk

The material explicitly states that no keys or environment variables are required, and no token, API key, or credential setup is described, so credential exposure or abuse risk appears minimal.

Network egressLow risk

No remote endpoints are declared, and the system flags it as prompt-only; based on the material, it only describes Pysa JSON/NDJSON syntax and does not indicate sending user data to external services.

Code executionLow risk

The current description presents a documentation/prompt-style skill for reading, writing, or debugging .models output format; there is no indication of spawning local processes, executing scripts, or invoking system capabilities.

Data accessLow risk

The material does not declare read/write access to files, directories, or other resources; although it mentions working with .models files, the provided information reads more like a syntax guide than an actual file-access tool, with no sign of overbroad permissions.

Supply chainCaution

The source points to an open-source GitHub repository, facebook/pyre-check, making the code auditable and lowering risk. However, the license is not stated, community adoption is listed as 0 stars, and maintenance status is unknown, so supply-chain transparency and upkeep remain somewhat unclear; verify repository mapping and recent activity before use.

Recommendations

Before use, confirm that the skill content actually maps to the relevant directory or documentation in github.com/facebook/pyre-check, rather than a repackaged third-party copy.
If handling sensitive analysis results, use it in an isolated environment and avoid pasting unredacted vulnerability data into other external tools.
Review recent commits, release history, and license information to confirm the project is still maintained before adopting it in production workflows.

Audited by: gpt-5.4 · 2026-06-17

// install

Copy the install command and let the AI configure it · recommended for beginners

Please install the "pysa-json-models" skill from askskill:
1. Download https://raw.githubusercontent.com/facebook/pyre-check/main/.llms/skills/pysa-json-models/SKILL.md
2. Save it as ~/.claude/skills/pysa-json-models/SKILL.md
3. Reload skills and tell me it's ready

// download

Download SKILL.mdInstall manifest ↗

// examples

Explain model fields

Prompt

Please explain the structure and field meanings of this Pysa JSON model, focusing on what sources, sinks, tito, sanitizers, and issues represent, and point out any possible formatting errors:

{...paste JSON content...}

Expected

A field-by-field explanation of the JSON plus diagnostic notes on possible syntax or modeling issues.

Generate a taint model

Prompt

Based on this Python function signature and behavior, generate a Pysa JSON taint model: parameter user_input is a source, parameter query flows to a sink, and the return value preserves TITO; output a valid .models JSON snippet with a brief explanation.

Function signature: def run_query(user_input: str, query: str) -> str

Expected

A valid JSON model snippet for a .models file, with an explanation of the source, sink, and TITO mappings.

Debug analysis results

Prompt

I found this issue in Pysa's .models output, but I'm not sure why it was triggered. Please analyze the taint propagation path using the model content, identify possible false-positive causes, and suggest how to adjust the model or code:

{...paste issue JSON and related model JSON...}

Expected

An explanation of why the issue was triggered, a taint-flow analysis, and concrete suggestions to reduce false positives or fix the problem.

// docs

Pysa JSON Model Syntax

Overview

Pysa outputs analysis results as newline-delimited JSON (NDJSON). Each line is a self-contained JSON object with "kind" and "data" fields. There are two kinds: "model" (a callable's taint behavior) and "issue" (a detected vulnerability).

Top-Level Wrapper

Every JSON object is wrapped as:

{"kind": "model", "data": { ... }}
{"kind": "issue", "data": { ... }}

Models and issues are separate top-level objects. Issues are never nested inside models.

Model Structure

{
  "callable": "module.function_name",
  "filename": "module.py",
  "callable_line": 42,
  "sources": [ ... ],
  "sinks": [ ... ],
  "tito": [ ... ],
  "parameter_sources": [ ... ],
  "global_sanitizer": { ... },
  "parameters_sanitizer": { ... },
  "sanitizers": [ ... ],
  "modes": [ "Obscure", ... ]
}

All fields except callable are optional. Empty fields are omitted entirely — never include empty arrays [] or objects {}.

Note: "sources" represents generations (taint produced by the function). This is distinct from "parameter_sources" which represents sources on parameters.

Callables

Regular functions: "module.function_name"
Methods: "module.ClassName.method_name"
Attribute models: "Obj{module.ClassName.attribute_name}"

Modes

Available modes: Obscure, SkipObscure, SkipAnalysis, SkipOverrides, AnalyzeAllOverrides, Entrypoint, IgnoreDecorator, SkipModelBroadening, InferSelfTito, InferArgumentTito.

Port Entries (sources/sinks/tito/parameter_sources)

Each of sources, sinks, tito, and parameter_sources is a list of port entries:

{
  "port": "<port>",
  "taint": [ <trace_element>, ... ]
}

Port Formats

Port	Meaning
`result`	Return value
`result[field]`	Return value with access path
`formal(name, position=N)`	Named parameter at position N
`formal(name, position=N, positional_only)`	Positional-only parameter
`formal(name, position=N)[field][subfield]`	Parameter with access path
`formal(*args, position=N)`	Variadic positional args
`formal(**kwargs)`	Variadic keyword args
`formal(**kwargs, excluded=[x])`	Kwargs excluding named params
`formal($global, position=0)`	Global/attribute model port

Key rule: position is always included in formal() ports (e.g., formal(x, position=0), not formal(x)).

For sources/parameter_sources, the port indicates where taint is produced (typically result or result[field]).

For sinks, the port indicates where taint is consumed (typically formal(...) with optional access path).

For tito, the port indicates the input side (always formal(...)). The output side is encoded inside the taint entry via return_paths.

Trace Elements (Call Info)

Each element in a "taint" list is a trace element keyed by its call info. There are four call info variants:

1. Declaration — user-specified taint from .pysa model files

{
  "kinds": [ { "kind": "Test" } ],
  "declaration": null
}

This is the leaf of the trace — the taint is directly declared by the user, not propagated from another function.

2. Origin — taint at a direct call site (first hop)

{
  "kinds": [ { "kind": "Test", "length": 0 } ],
  "origin": { "line": 16, "start": 15, "end": 20 }
}

Represents a call to a function with a user-declared model. The origin location is where the call happens. "call_site" may also be present (e.g., "call_site": "16:4-16:21").

3. Call — taint propagated through a call chain

{
  "kinds": [ { "kind": "Test", "length": 2 } ],
  "call": {
    "position": { "line": 20, "start": 8, "end": 22 },
    "resolves_to": [ "module.callee_function" ],
    "port": "result[a]"
  }
}

…

View full docs ↗