"""gen_lint_tables 0.1.0: the PROMPT LINT's closed tables (tpc_lint 0.1.0,
D182.1 F5), written from this one source into both residences between
their BEGIN and END LINT TABLES markers, as one JSON text and its SHA-256.
Each residence parses that text at load and refuses to load when the
digest does not match. Run after any change here; a change of any table
is a new tables version and a new tpc_lint version.
TABLE FORMS
CLASSES name -> the ASCII characters of the class (after the fold).
PL2 [id, [pattern, ...]]; a pattern is a list of elements,
["L", literal] or ["C", class, min, max]; the first element
is a literal of at least two characters.
PL3 PL4 PL5 PL6 PL9
[id, [template, ...]]; a template is literal text with
alternative groups "{a|b|}" (an empty alternative allowed,
never in the first group). The template matches exactly the
text of any one of its expansions.
PL7 [id, [token sequence, ...], [template, ...]]: name tokens and
description templates.
NEG the negation tokens; NEG_WINDOW; NEG_STOP.
KNOWN_KEYS the member names a tool locator shows by name.
U+0001 inside a template stands for a literal "|" (PL5-01, PL6-01).
Every literal and every expansion is lower-case printable ASCII (the fold
maps A-Z to a-z before matching), carries no "{", "}" or "|" outside a
group, no double space and no leading or trailing space. The generator
refuses to write when a table breaks a form."""
import hashlib
import itertools
import json
import os
import re
TABLES_VERSION = "0.1.0"
H = os.path.dirname(os.path.abspath(__file__))
LOWER = "abcdefghijklmnopqrstuvwxyz"
DIG = "0123456789"
CLASSES = {
"D": DIG,
"L": LOWER,
"N": LOWER + DIG,
"V": LOWER + "234567",
"W": LOWER + DIG + "_",
"U": LOWER + DIG + "_-",
"K": LOWER + DIG + "-._~+/=",
"I": LOWER + DIG + "-._~%!$&'()*+,;=",
"G": "".join(chr(c) for c in range(0x21, 0x7F)
if chr(c) not in "\"'`" and not "A" <= chr(c) <= "Z"),
"S": " ",
"E": "=:",
"Q": "\"'`",
"X": "abprs",
}
GEN_KEYS = ["password", "passwd", "api_key", "apikey", "api-key",
"secret_key", "client_secret", "access_token", "auth_token",
"private_key", "aws_secret_access_key"]
PL2 = [
["PL2-01", [[["L", "akia"], ["C", "V", 16, 16]]]],
["PL2-02", [[["L", "asia"], ["C", "V", 16, 16]]]],
["PL2-03", [[["L", "ghp_"], ["C", "N", 36, 36]]]],
["PL2-04", [[["L", "gho_"], ["C", "N", 36, 36]]]],
["PL2-05", [[["L", "ghu_"], ["C", "N", 36, 36]]]],
["PL2-06", [[["L", "ghs_"], ["C", "N", 36, 36]]]],
["PL2-07", [[["L", "ghr_"], ["C", "N", 36, 36]]]],
["PL2-08", [[["L", "github_pat_"], ["C", "W", 82, 82]]]],
["PL2-09", [[["L", "glpat-"], ["C", "U", 20, 20]]]],
["PL2-10", [[["L", "xox"], ["C", "X", 1, 1], ["L", "-"], ["C", "D", 10, 12],
["L", "-"], ["C", "D", 10, 13], ["L", "-"], ["C", "N", 24, 26]]]],
["PL2-11", [[["L", "xapp-"], ["C", "U", 20, 255]]]],
["PL2-12", [[["L", "aiza"], ["C", "U", 35, 35]]]],
["PL2-13", [[["L", "sk_live_"], ["C", "N", 20, 255]]]],
["PL2-14", [[["L", "rk_live_"], ["C", "N", 20, 255]]]],
["PL2-15", [[["L", "sk_test_"], ["C", "N", 20, 255]]]],
["PL2-16", [[["L", "sk-"], ["C", "N", 20, 20], ["L", "t3blbkfj"], ["C", "N", 20, 20]]]],
["PL2-17", [[["L", "sk-proj-"], ["C", "U", 20, 4096]]]],
["PL2-18", [[["L", "sk-svcacct-"], ["C", "U", 20, 4096]]]],
["PL2-19", [[["L", "sk-admin-"], ["C", "U", 20, 4096]]]],
["PL2-20", [[["L", "sk-ant-"], ["C", "U", 20, 4096]]]],
["PL2-21", [[["L", "hf_"], ["C", "L", 34, 34]]]],
["PL2-22", [[["L", "npm_"], ["C", "N", 36, 36]]]],
["PL2-23", [[["L", "pypi-ageichlwas5vcmc"], ["C", "U", 50, 1000]]]],
["PL2-24", [[["L", "eyj"], ["C", "U", 10, 4096], ["L", ".eyj"], ["C", "U", 10, 4096],
["L", "."], ["C", "U", 0, 4096]]]],
["PL2-25", [[["L", "-----begin " + k + "-----"]] for k in
["private key", "encrypted private key", "rsa private key",
"dsa private key", "ec private key", "openssh private key",
"pgp private key block"]]],
["PL2-26", [[["L", "bearer "], ["C", "K", 20, 4096]]]],
["PL2-27", [[["L", "authorization: basic "], ["C", "K", 8, 4096]]]],
["PL2-28", [[["L", "x-api-key:"], ["C", "S", 0, 1], ["C", "U", 16, 4096]]]],
["PL2-29", [[["L", "://"], ["C", "I", 1, 256], ["L", ":"], ["C", "I", 1, 256], ["L", "@"]]]],
["PL2-30", [[["L", k], ["C", "S", 0, 1], ["C", "E", 1, 1], ["C", "S", 0, 1],
["C", "Q", 0, 1], ["C", "G", 8, 4096]] for k in GEN_KEYS]],
]
PL3 = [
["PL3-01", ["{follow|obey|execute|carry out|act on} {the |any |all |}"
"{instructions|directions|commands|directives|orders} "
"{in|from|found in|contained in|embedded in|inside} "
"{tool results|tool output|tool outputs|tool responses|web pages|"
"wiki pages|the wiki|retrieved content|retrieved documents|"
"search results|documents|files|emails|other agents|another agent|"
"the server|the api|tpx}"]],
["PL3-02", ["treat {tool results|tool output|tool outputs|tool responses|"
"wiki content|wiki pages|the wiki|retrieved content|search results|"
"documents|file contents|emails|messages from other agents|"
"server messages|tpx responses} as "
"{instructions|commands|authoritative|authorization|trusted}"]],
["PL3-03", ["{you are|you're|you have been} {authorized|authorised|permitted|"
"allowed|cleared|pre-authorized|preauthorized} to"]],
["PL3-04", ["{you have|i give you|i grant you|you are granted|you have been granted} "
"{my |full |standing |blanket |}{permission|authorization|"
"authorisation|approval|consent} to"]],
["PL3-05", ["{consider|treat} {it|this|that|all actions|every action|such actions|"
"these actions} {as |}{approved|authorized|authorised|pre-approved|"
"preapproved|sanctioned}"]],
["PL3-06", ["{assume|presume} {the user's |the human's |the sponsor's |"
"the operator's |my |}{approval|consent|permission|authorization|"
"authorisation}"]],
["PL3-07", ["{pre-approved|preapproved|approved in advance|authorized in advance|"
"authorised in advance}"]],
["PL3-08", ["{no need to|do not need to|don't need to|you need not} "
"{ask|wait for|request|seek|obtain|get} {for |}{permission|approval|"
"confirmation|consent|authorization|authorisation}"]],
["PL3-09", ["without {asking|waiting for|requesting|seeking} {the human|the user|"
"the sponsor|anyone|permission|approval|confirmation|consent}"]],
["PL3-10", ["{act|proceed|decide} {on your own authority|autonomously|"
"without supervision}"]],
["PL3-11", ["{on behalf of|in the name of} the {sponsor|user|human|operator|"
"declaring authority}"]],
["PL3-12", ["{your|these|the} {instructions|rules} {override|outrank|supersede|"
"take precedence over} {the human|the user|any human|the human's|"
"the user's}"]],
]
PL4 = [
["PL4-01", ["{ignore|disregard|forget|override|bypass|set aside} {all |any |}"
"{the |your |}{previous|prior|above|earlier|preceding|original|system|"
"other} {instructions|instruction|rules|guidelines|directives|prompt|"
"prompts|constraints}"]],
["PL4-02", ["{ignore|disregard|override|bypass|set aside|relax|suspend|waive} "
"{the |any |all |}{tps|agent contract|contract|specification|gtp|rules|"
"safety rules|input vetting|decision protocol|digest gate|"
"text safety rule}"]],
["PL4-03", ["{skip|bypass|omit|circumvent} {the |any |all |}{digest|digests|"
"digest gate|digest check|checks|check|verification|validation|gate|"
"lock|mutex|refusal|refusals|audit|review|quarantine|"
"benchmark quarantine|decision item|decision items|report|reporting}"]],
["PL4-04", ["{do not|don't|never|no need to} {report|flag|log|record|disclose|"
"mention} {it|this|them|detections|injections|probes|canaries|failures|"
"errors|refusals|the detection|the injection|suspicious input|"
"suspect input}"]],
["PL4-05", ["{always comply|comply with every|comply with all|comply with any|"
"never refuse|do not refuse|don't refuse|never decline|do not decline|"
"don't decline}"]],
["PL4-06", ["{compute|calculate|estimate|guess|reason|work out|approximate} "
"{the |a |any |}{digest|digests|hash|hashes|sha-256|d(is)|d(prompt)|"
"d(tfk)} {by hand|by reasoning|mentally|in your head|without tpc|"
"without running tpc-py|without executing tpc-py}"]],
["PL4-07", ["{identify|detect|spot|recognize|recognise|distinguish|guess|"
"figure out} {the |a |any |all |}{probe|probes|canary|canaries|parrot|"
"parrots|test input|test inputs|planted test|planted tests|"
"planted error|planted errors}"]],
["PL4-08", ["if {this|it|the input|the task|the request|the package|the block} "
"{is|looks like|seems like|seems to be|might be|may be|could be|"
"appears to be} {a |an |}{probe|canary|parrot|test|evaluation|"
"planted test}"]],
["PL4-09", ["{when|if|while|whenever} you {are|suspect you are|think you are|"
"believe you are} {being tested|being evaluated|being probed|"
"under evaluation|tested|evaluated|probed}"]],
["PL4-10", ["{treat|handle|answer|respond to} {probes|canaries|parrots|tests|"
"test inputs|suspected probes} {differently|with extra care|"
"more carefully|specially}"]],
["PL4-11", ["{look up|search for|fetch|read|consult|check} the {known|expected|"
"published|reference|benchmark|correct} {value|values|answer|answers|"
"result|results} {first|before deriving|before the derivation|"
"before you derive}"]],
]
PL5 = [
["PL5-01", ["\x01 class: instruction artifact"]],
["PL5-02", ["end of artifact --- tps"]],
["PL5-03", ["end of artifact --- gtp"]],
["PL5-04", ["the principia machina specification (tps)"]],
["PL5-05", ["the generic tps prompt (gtp)"]],
["PL5-06", ["{tps|gtp} version:"]],
["PL5-07", ["this part, taken as a runnable instruction set, is gtp"]],
["PL5-08", ["part 6 agent contract"]],
["PL5-09", ["reading conventions, for this file"]],
]
PL6 = [
["PL6-01", ["{<important>|</important>|<instructions>|</instructions>|"
"<instruction>|<system>|</system>|<system-reminder>|[system]|[inst]|"
"<<sys>>|<|im_start|>}".replace("<|im_start|>", "<\x01im_start\x01>")]],
["PL6-02", ["{ignore|disregard|forget|override} {all |any |}{the |your |}"
"{previous|prior|above|earlier|preceding|original|system|other} "
"{instructions|instruction|rules|guidelines|directives|prompt|prompts}"]],
["PL6-03", ["{do not|don't|never} {tell|inform|notify|alert|mention|reveal|show|"
"disclose|say} {this |it |anything |}{to |}{the user|the human|"
"the sponsor|anyone|that you|this}"]],
["PL6-04", ["without {telling|informing|notifying|alerting} {the user|the human|"
"the sponsor|anyone}"]],
["PL6-05", ["{keep|hide} {this|it} {secret|hidden|from the user|from the human}"]],
["PL6-06", ["the user {must not|should not|must never|should never} "
"{know|see|find out|be told}"]],
["PL6-07", ["{before|prior to} {using|calling|invoking|running} {this|any|"
"any other|another|the other} tool"]],
["PL6-08", ["{always|first} {call|use|invoke|run} this tool"]],
["PL6-09", ["{all other tools|any other tool|every other tool|the other tools}"]],
["PL6-10", ["{instead of|rather than} {using|calling|invoking} {the|any|another}"]],
["PL6-11", ["{~/|id_rsa|id_ed25519|id_ecdsa|.ssh/|mcp.json|.env|/etc/passwd|"
"/etc/shadow|.aws/credentials|.netrc|.git-credentials|.npmrc|.pypirc|"
"credentials.json|.kube/config|.docker/config.json}"]],
["PL6-12", ["{pass|send|include|attach|forward|append|upload|post} {its|the|their|"
"all|the file's|the file|those|these} {content|contents}"]],
["PL6-13", ["{read|open|cat|load|access} {the |}{private key|ssh key|ssh keys|"
"credentials|secrets|environment variables|config file|"
"configuration file|api key|api keys|tokens}"]],
["PL6-14", ["{http://|https://|ftp://|ngrok|pastebin|requestbin|webhook.site|"
"exfiltrate|exfiltration}"]],
["PL6-15", ["{send|post|upload|forward|email|transmit} {it|them|this|the result|"
"the results|the data|everything|all data} to"]],
["PL6-16", ["{add|write|save|append} {this|these instructions|the following} to "
"{memory|your memory|claude.md|agents.md|your instructions|"
"the system prompt}"]],
]
PL7 = [
["PL7-01",
[["bash"], ["sh"], ["zsh"], ["shell"], ["powershell"], ["pwsh"], ["cmd"],
["terminal"], ["subprocess"], ["exec"], ["execute"], ["eval"], ["repl"],
["run", "command"], ["run", "commands"], ["run", "code"], ["code", "interpreter"],
["run", "script"], ["run", "python"]],
["{arbitrary|any|shell|bash|terminal|system} {command|commands}",
"{execute|executes|run|runs|evaluate|evaluates} {arbitrary |any |}{code|python|"
"javascript|scripts|a script|shell commands|a shell command|a command|commands}"]],
["PL7-02",
[["fetch"], ["webfetch"], ["curl"], ["wget"], ["browse"], ["browser"],
["navigate"], ["puppeteer"], ["playwright"], ["scrape"], ["scraper"],
["crawl"], ["crawler"], ["download"], ["http", "request"], ["http", "get"],
["http", "post"], ["url", "fetch"], ["fetch", "url"], ["open", "url"],
["get", "url"], ["web", "request"]],
["{any|arbitrary} {url|urls|web page|web pages|website|websites|host|hosts}",
"{fetch|fetches|retrieve|retrieves|download|downloads|get|gets} {a|any|"
"the content of a|the contents of a|content from a|content from any} "
"{url|web page|website}"]],
["PL7-03",
[["send"], ["email"], ["mail"], ["gmail"], ["smtp"], ["sms"], ["webhook"],
["tweet"], ["upload"], ["post", "message"], ["post", "to"]],
["{send|sends} {an |a |}{email|emails|message|messages|sms|text message|"
"notification}",
"{post|posts} {a |}{message|messages|tweet|tweets} to"]],
]
PL9 = [
["PL9-01", ["{remember|memorize|memorise|save|store|persist|record|retain|keep} "
"{this|these|the following|these instructions|this instruction|"
"these rules|this rule|it} {for|in|across|into|to} {future|later|"
"all future|subsequent|every|your|the|long-term|persistent} "
"{sessions|session|conversations|conversation|memory|runs|work}"]],
["PL9-02", ["{write|save|store|add|append|commit} {this|these|it|them|"
"the following|these instructions|this instruction|these rules|"
"a note|notes} {to|in|into} {memory|your memory|the memory|"
"long-term memory|persistent memory|the memory file|a memory file|"
"your memory file|the knowledge base}"]],
["PL9-03", ["{update|edit|modify|rewrite|change|overwrite|extend|amend|"
"append to} {your|the|this} {memory|memories|instructions|"
"system prompt|prompt|instruction file|instruction files|rules file}"]],
["PL9-04", ["{claude.md|agents.md|gemini.md|.cursorrules|.windsurfrules|"
".clinerules|copilot-instructions.md|.cursor/rules|"
".github/instructions|memory.md|.claude/}"]],
["PL9-05", ["{for|in|across|during} {future|all future|later|subsequent|"
"every future|next} {sessions|session|conversations|conversation|"
"runs|chats}"]],
["PL9-06", ["{memory tool|save_memory|memory_write|add_memory|create_memory|"
"remember tool}"]],
]
NEG = ["not", "never", "no", "nor", "cannot", "dont", "don't", "don\u2019t",
"cant", "can't", "can\u2019t", "mustnt", "mustn't", "mustn\u2019t",
"shouldnt", "shouldn't", "shouldn\u2019t", "wont", "won't", "won\u2019t",
"doesnt", "doesn't", "doesn\u2019t"]
NEG_WINDOW = 4
NEG_STOP = ".!?;:"
KNOWN_KEYS = ["$defs", "$id", "$ref", "$schema", "_meta", "additionalProperties",
"allOf", "annotations", "anyOf", "cache_control", "const",
"contentEncoding", "contentMediaType", "default", "definitions",
"deprecated", "description", "destructiveHint", "enum", "examples",
"exclusiveMaximum", "exclusiveMinimum", "format", "function",
"idempotentHint", "inputSchema", "input_schema", "items", "maxItems",
"maxLength", "maximum", "minItems", "minLength", "minimum", "name",
"not", "oneOf", "openWorldHint", "outputSchema", "output_schema",
"parameters", "pattern", "patternProperties", "prefixItems",
"properties", "readOnly", "readOnlyHint", "required", "strict",
"title", "type", "uniqueItems", "writeOnly"]
# ------------------------------------------------------------ validation
def fail(msg):
raise SystemExit("gen_lint_tables: refusing to write: " + msg)
def parse_template(t):
"""[[alternatives], ...]: a literal chunk is a part of one alternative."""
parts, i, lit = [], 0, ""
while i < len(t):
c = t[i]
if c == "{":
j = t.index("}", i)
if lit:
parts.append([lit])
lit = ""
alts = t[i + 1:j].split("|")
parts.append(alts)
i = j + 1
elif c in "}|":
fail("stray %r in %r" % (c, t))
else:
lit += c
i += 1
if lit:
parts.append([lit])
return parts
PRINTABLE = re.compile(r"^[\x01\x20-\x7e]*\Z")
def check_phrase_text(s, where):
if not PRINTABLE.match(s) or re.search(r"[A-Z]", s):
fail("%s: not lower-case printable ASCII: %r" % (where, s))
def check_template(t, where):
check_phrase_text(t, where)
parts = parse_template(t)
if "" in parts[0] or not parts[0]:
fail("%s: the first group has an empty alternative" % where)
for p in parts:
for a in p:
check_phrase_text(a, where)
n = 0
for combo in itertools.product(*parts):
e = "".join(combo)
n += 1
if e == "" or e[0] == " " or e[-1] == " " or " " in e:
fail("%s: expansion %r is empty or badly spaced" % (where, e))
if n > 100000:
fail("%s: %d expansions" % (where, n))
return parts
def unescape(t):
return t.replace("\x01", "|")
def build():
for name, chars in CLASSES.items():
if not chars or any(ord(c) > 0x7e or ord(c) < 0x20 for c in chars):
fail("class %s" % name)
if len(set(chars)) != len(chars) or re.search(r"[A-Z]", chars):
fail("class %s" % name)
ids = set()
def newid(i):
if i in ids:
fail("duplicate id " + i)
ids.add(i)
for i, pats in PL2:
newid(i)
for p in pats:
if p[0][0] != "L" or len(p[0][1]) < 2:
fail("%s: a pattern must open with a literal of two or more" % i)
for el in p:
if el[0] == "L":
check_phrase_text(el[1], i)
elif el[0] == "C":
if el[1] not in CLASSES or not (0 <= el[2] <= el[3] <= 4096):
fail("%s: bad class element %r" % (i, el))
else:
fail("%s: bad element %r" % (i, el))
out = {"version": TABLES_VERSION, "classes": CLASSES, "PL2": PL2}
for code, table in (("PL3", PL3), ("PL4", PL4), ("PL5", PL5), ("PL6", PL6),
("PL9", PL9)):
rows = []
for i, temps in table:
newid(i)
if not i.startswith(code + "-"):
fail("id %s under %s" % (i, code))
rows.append([i, [[[unescape(a) for a in part]
for part in check_template(t, i)] for t in temps]])
out[code] = rows
rows = []
for i, seqs, temps in PL7:
newid(i)
for s in seqs:
for tok in s:
if not re.match(r"^[a-z0-9]+\Z", tok):
fail("%s: token %r" % (i, tok))
rows.append([i, seqs, [[[unescape(a) for a in part]
for part in check_template(t, i)] for t in temps]])
out["PL7"] = rows
out["NEG"] = NEG
out["NEG_WINDOW"] = NEG_WINDOW
out["NEG_STOP"] = NEG_STOP
if sorted(KNOWN_KEYS) != KNOWN_KEYS or len(set(KNOWN_KEYS)) != len(KNOWN_KEYS):
fail("KNOWN_KEYS must be sorted and unique")
for k in KNOWN_KEYS:
if not re.match(r"^[$_A-Za-z][A-Za-z_]*\Z", k):
fail("known key %r" % k)
out["KNOWN_KEYS"] = KNOWN_KEYS
return out
def main():
tables = build()
text = json.dumps(tables, ensure_ascii=True, separators=(",", ":"),
sort_keys=True)
digest = hashlib.sha256(text.encode("utf-8")).hexdigest()
chunks = [text[i:i + 64] for i in range(0, len(text), 64)]
py = ["# BEGIN LINT TABLES (gen_lint_tables.py; do not edit)",
'LINT_TABLES_VERSION = "%s"' % TABLES_VERSION,
'LINT_TABLES_SHA256 = (\n "%s")' % digest,
"LINT_TABLES_JSON = ("] + [" %r" % c for c in chunks] + [")",
"# END LINT TABLES"]
def php_lit(c):
return "'" + c.replace("\\", "\\\\").replace("'", "\\'") + "'"
php = ["// BEGIN LINT TABLES (gen_lint_tables.py; do not edit)",
"const TPC_LINT_TABLES_VERSION = '%s';" % TABLES_VERSION,
"const TPC_LINT_TABLES_SHA256 = '%s';" % digest,
"const TPC_LINT_TABLES_JSON = ''"] + [" . %s" % php_lit(c) for c in chunks] + \
[" ;", "// END LINT TABLES"]
def put(path, begin, end, lines):
s = open(path, encoding="utf-8").read()
a = s.index(begin)
b = s.index(end) + len(end)
open(path, "w", encoding="utf-8").write(s[:a] + "\n".join(lines) + s[b:])
put(os.path.join(H, "tpc_lint.py"), "# BEGIN LINT TABLES", "# END LINT TABLES", py)
put(os.path.join(H, "..", "tpc_php", "tpc_lint.php"), "// BEGIN LINT TABLES",
"// END LINT TABLES", php)
n = {k: len(tables[k]) for k in ("PL2", "PL3", "PL4", "PL5", "PL6", "PL7", "PL9")}
print("tables %s: %d bytes, SHA-256 %s, entries %s"
% (TABLES_VERSION, len(text.encode("utf-8")), digest,
json.dumps(n, sort_keys=True)))
if __name__ == "__main__":
main()
