@thedecipherist/claude-packs 0.0.0-stage → 1.0.0

package/packs/multi-tenant/checks/tenant-filter-from-url.json

@@ -0,0 +1,25 @@
+{
+  "id": "tenant-filter-from-url",
+  "why": "A query that takes its key from the URL and carries no tenant key reads or writes any tenant.",
+  "rule": ".claude/rules/no-role-crosses-a-tenant.md",
+  "globs": [
+    "**/routes/**/*.ts",
+    "**/routes/**/*.js",
+    "**/app/api/**/route.ts"
+  ],
+  "exclude": [
+    "**/tests/**",
+    "**/test/**",
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/e2e/**",
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.next/**"
+  ],
+  "pattern": "\\b(?:queryOne|updateOne|deleteOne|updateMany|deleteMany|findOne|findOneAndUpdate)(?:<[^(]*?>)?\\(\\s*'[\\w-]+'\\s*,\\s*\\{(?:(?!company_id|tenant_id|org_id|account_id|\\.\\.\\.)[^{}])*(?:req\\.params|\\bslug\\b)(?:(?!company_id|tenant_id|org_id|account_id|\\.\\.\\.)[^{}])*\\}",
+  "bad": "await deleteOne('companies', { slug: req.params.slug });",
+  "good": "await deleteOne('companies', { slug: req.params.slug, company_id: user.company_id });",
+  "kind": "security"
+}

package/packs/multi-tenant/pack.json

@@ -0,0 +1,22 @@
+{
+  "name": "multi-tenant",
+  "version": "1.0.0",
+  "description": "One system, many customers: no role crosses a tenant, every query carries the tenant key, and isolation is proved with a second tenant.",
+  "type": "stock",
+  "author": "claude-packs",
+  "license": "MIT",
+  "homepage": "https://github.com/TheDecipherist/claude-packs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TheDecipherist/claude-packs.git",
+    "directory": "packs/multi-tenant"
+  },
+  "keywords": [
+    "tenant",
+    "saas",
+    "security"
+  ],
+  "engines": {
+    "claude-packs": ">=0.25.0"
+  }
+}

package/packs/multi-tenant/rules/no-role-crosses-a-tenant.md

@@ -0,0 +1,21 @@
+---
+paths:
+  - "**/*.ts"
+  - "**/*.js"
+---
+
+# No role inside a tenant ever crosses one, and isolation is proved with a second tenant
+
+<constraints>
+Always do:
+- Put the tenant key first in every query, taken from the session, never from the URL.
+- Keep platform administration a separate identity, not the highest tenant role.
+- Prove isolation with the `prove-tenant-isolation` skill.
+
+Never do:
+- Give a self-registered account a role that reads other tenants.
+- Update or delete on a slug or an `_id` alone.
+</constraints>
+
+## Check
+`tenant-filter-from-url`, `role-sees-all-tenants`.

package/packs/multi-tenant/skills/prove-tenant-isolation/SKILL.md

@@ -0,0 +1,19 @@
+---
+name: prove-tenant-isolation
+description: Use when a route, a query or a role in a multi-tenant system is added or changed, or when asked whether one customer can reach another's data.
+---
+
+# Prove tenant isolation (one job: tenant B's id gets nothing from tenant A's session)
+
+<constraints>
+Always do:
+1. Make two tenants in the test, against a real data store, each with its own records.
+2. List every route that takes an id, and every message type that names one.
+3. For each, call it as tenant A with tenant B's id, and expect 404 or an empty list, for reads, updates and deletes.
+4. Read tenant B's record afterwards: it must be unchanged.
+5. Do the same with every role a sign-up can reach.
+
+Never do:
+- Mock the data layer here: the filter is what is under test.
+- Accept 403 where 404 hides that the record exists.
+</constraints>

package/packs/nginx/checks/modsec-no-blanket-off.json

@@ -0,0 +1,16 @@
+{
+  "id": "modsec-no-blanket-off",
+  "why": "ctl:ruleEngine=Off or SecRuleEngine Off for a path turns the WAF off exactly where it is needed. Exclude one rule for one URI with ctl:ruleRemoveById.",
+  "rule": ".claude/rules/modsecurity-tuning.md",
+  "concepts": [
+    "modsec"
+  ],
+  "exclude": [
+    "**/node_modules/**"
+  ],
+  "code": false,
+  "pattern": "ctl:ruleEngine=Off|^\\s*SecRuleEngine\\s+Off\\b",
+  "flags": "m",
+  "bad": "SecRule REQUEST_URI \"@beginsWith /api\" \"id:1000,phase:1,pass,nolog,ctl:ruleEngine=Off\"",
+  "good": "SecRule REQUEST_URI \"@beginsWith /api/orders\" \"id:999100,phase:1,pass,nolog,ctl:ruleRemoveById=942100\""
+}

package/packs/nginx/checks/nginx-csp-no-unsafe.json

@@ -0,0 +1,15 @@
+{
+  "id": "nginx-csp-no-unsafe",
+  "why": "'unsafe-inline' / 'unsafe-eval' make the CSP decorative. Use a nonce or a hash for the one inline script that needs it.",
+  "rule": ".claude/rules/nginx-production.md",
+  "concepts": [
+    "nginx-conf"
+  ],
+  "exclude": [
+    "**/node_modules/**"
+  ],
+  "code": false,
+  "pattern": "'unsafe-(?:inline|eval)'",
+  "bad": "add_header Content-Security-Policy \"script-src 'self' 'unsafe-inline'\" always;",
+  "good": "add_header Content-Security-Policy \"script-src 'self' 'nonce-$request_id'; object-src 'none'; base-uri 'self'\" always;"
+}

package/packs/nginx/checks/nginx-headers-always.json

@@ -0,0 +1,15 @@
+{
+  "id": "nginx-headers-always",
+  "why": "add_header without `always` is dropped on 4xx/5xx responses, so error pages ship without nosniff, frame protection or HSTS.",
+  "rule": ".claude/rules/nginx-production.md",
+  "concepts": [
+    "nginx-conf"
+  ],
+  "exclude": [
+    "**/node_modules/**"
+  ],
+  "code": false,
+  "pattern": "\\badd_header\\s+(?:X-Frame-Options|X-Content-Type-Options|Strict-Transport-Security|Content-Security-Policy(?:-Report-Only)?|Referrer-Policy)\\b(?![^;]*\\balways\\b)",
+  "bad": "add_header X-Content-Type-Options nosniff;",
+  "good": "add_header X-Content-Type-Options nosniff always;"
+}

package/packs/nginx/checks/nginx-keepalive-http11.json

@@ -0,0 +1,20 @@
+{
+  "id": "nginx-keepalive-http11",
+  "why": "upstream keepalive only works with HTTP/1.1 and a cleared Connection header; without them every proxied request opens a new connection.",
+  "rule": ".claude/rules/nginx-production.md",
+  "concepts": [
+    "nginx-conf"
+  ],
+  "exclude": [
+    "**/node_modules/**"
+  ],
+  "code": false,
+  "mode": "needs",
+  "pattern": "\\bkeepalive\\s+\\d+\\s*;",
+  "needs": [
+    "proxy_http_version\\s+1\\.1",
+    "proxy_set_header\\s+Connection\\s+\\\"\\\""
+  ],
+  "bad": "upstream api { server api:3000; keepalive 32; }",
+  "good": "upstream api { server api:3000; keepalive 32; }\nlocation / { proxy_http_version 1.1; proxy_set_header Connection \"\"; proxy_pass http://api; }"
+}

package/packs/nginx/checks/nginx-logs-to-stdout.json

@@ -0,0 +1,15 @@
+{
+  "id": "nginx-logs-to-stdout",
+  "why": "A log file inside the container is invisible to the Docker log driver and fills the writable layer. /dev/stdout and /dev/stderr.",
+  "rule": ".claude/rules/nginx-production.md",
+  "concepts": [
+    "nginx-conf"
+  ],
+  "exclude": [
+    "**/node_modules/**"
+  ],
+  "code": false,
+  "pattern": "\\b(?:access|error)_log\\s+/var/log/",
+  "bad": "access_log /var/log/nginx/access.log;",
+  "good": "access_log /dev/stdout json;\nerror_log /dev/stderr warn;"
+}

package/packs/nginx/checks/nginx-no-crlf.json

@@ -0,0 +1,17 @@
+{
+  "id": "nginx-no-crlf",
+  "why": "A CRLF nginx.conf fails nginx -t inside a Linux container with a nonsensical error. LF only.",
+  "rule": ".claude/rules/nginx-production.md",
+  "concepts": [
+    "nginx-conf",
+    "modsec"
+  ],
+  "exclude": [
+    "**/node_modules/**"
+  ],
+  "code": false,
+  "flags": "m",
+  "pattern": "\\r$",
+  "bad": "server {\r\n}\r\n",
+  "good": "server {\n}\n"
+}

package/packs/nginx/checks/nginx-resolver-ttl.json

@@ -0,0 +1,19 @@
+{
+  "id": "nginx-resolver-ttl",
+  "why": "Without a resolver with a TTL, NGINX resolves the upstream once at startup and keeps sending traffic to a replaced container's dead IP.",
+  "rule": ".claude/rules/nginx-production.md",
+  "concepts": [
+    "nginx-conf"
+  ],
+  "exclude": [
+    "**/node_modules/**"
+  ],
+  "code": false,
+  "mode": "needs",
+  "pattern": "\\bproxy_pass\\b",
+  "needs": [
+    "\\bresolver\\s+127\\.0\\.0\\.11\\b"
+  ],
+  "bad": "location / { proxy_pass http://api:3000; }",
+  "good": "http { resolver 127.0.0.11 ipv6=off valid=10s; server { location / { set $api http://api:3000; proxy_pass $api; } } }"
+}

package/packs/nginx/pack.json

@@ -0,0 +1,43 @@
+{
+  "name": "nginx",
+  "version": "1.0.0",
+  "description": "NGINX in front of containers: Docker DNS resolver, keepalive, stdout logs, headers with always, CSP, ModSecurity/CRS tuning.",
+  "type": "stock",
+  "author": "claude-packs",
+  "license": "MIT",
+  "homepage": "https://github.com/TheDecipherist/claude-packs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TheDecipherist/claude-packs.git",
+    "directory": "packs/nginx"
+  },
+  "keywords": [
+    "nginx",
+    "waf"
+  ],
+  "engines": {
+    "claude-packs": ">=0.19.0"
+  },
+  "folders": {},
+  "concepts": {
+    "nginx-conf": [
+      "**/nginx.conf",
+      "**/*.nginx.conf",
+      "**/nginx/**",
+      "**/conf.d/**/*.conf",
+      "**/sites-enabled/**"
+    ],
+    "modsec": [
+      "**/modsecurity.conf",
+      "**/modsecurity.d/**",
+      "**/modsec*/**",
+      "**/crs-setup.conf",
+      "**/*.modsec.conf",
+      "**/owasp-crs/**",
+      "**/REQUEST-*.conf",
+      "**/RESPONSE-*.conf"
+    ]
+  },
+  "skillsIn": null,
+  "hooks": {}
+}

package/packs/nginx/rules/modsecurity-tuning.md

@@ -0,0 +1,22 @@
+---
+# concepts: modsec
+paths:
+  - "placeholder"
+---
+
+# ModSecurity + CRS: detect first, tune to the stack, exclude narrowly
+
+<constraints>
+Always do:
+- `SecRuleEngine DetectionOnly` for the first 2 to 4 weeks; flip to `On` only after the audit log has been tuned. Shipping blocking mode on day one is how a team rips the WAF back out.
+- Start at paranoia level 1; raise only after real exclusion work. Tuning is about the anomaly score, not one rule.
+- Tune to the stack. Node + MongoDB: the real threat is NoSQL injection, which the SQLi rules miss: add rules that block MongoDB operators in parameters and JSON bodies (`$gt`, `$ne`, `$where`, `$regex`), prototype pollution (`__proto__`, `constructor.prototype`) and server-side JS; drop the PHP, Java and IIS rule files; keep SQLi only if SQL exists anywhere in the architecture.
+- Exclusions are targeted: one rule, one URI or parameter, `ctl:ruleRemoveById=…` scoped with `SecRule REQUEST_URI "@beginsWith /api/orders"`. JSON APIs are the usual false-positive source; scope to the API paths.
+- Skip static assets and health endpoints from inspection; cap scanned body sizes; keep response-body inspection on for data-leakage rules; update the CRS regularly; ship the audit log to the SIEM.
+- Test every rule change two ways: known attack payloads must be detected, replayed real traffic must still pass.
+
+Never do:
+- `ctl:ruleEngine=Off` for a whole path, or a blanket allowlist (`modsec-no-blanket-off`): it turns the WAF off exactly where it is needed.
+- Paranoia 3 or 4 as a default.
+- Let the WAF stand in for input validation, safe query construction and CSP in the app; it is the layer on top.
+</constraints>

package/packs/nginx/rules/nginx-production.md

@@ -0,0 +1,26 @@
+---
+# concepts: nginx-conf
+paths:
+  - "placeholder"
+---
+
+# NGINX in front of containers resolves by name with a TTL, logs to stdout, and sends headers always
+
+<constraints>
+Always do:
+- `resolver 127.0.0.11 ipv6=off valid=10s;` in `http {}` and upstreams by **service name** in a variable (`set $api http://api:3000; proxy_pass $api;`): NGINX otherwise resolves once at startup and keeps sending traffic to a replaced container's dead IP (`nginx-resolver-ttl`).
+- `keepalive` in the upstream with `proxy_http_version 1.1;` and `proxy_set_header Connection "";` (`nginx-keepalive-http11`).
+- `access_log /dev/stdout json;` and `error_log /dev/stderr;` with a JSON log format; never a file inside the container (`nginx-logs-to-stdout`).
+- `/health` and `stub_status` on an internal-only port with `access_log off` and `allow`/`deny`, never on the public port.
+- A non-HTTP upstream (MongoDB) goes in a top-level `stream {}` block, outside `http {}`.
+- TLS: modern protocols and ciphers, session cache, OCSP stapling, certs from Docker secrets at `/run/secrets/`.
+- Security headers with `always` so error responses carry them too (`nginx-headers-always`): `X-Content-Type-Options nosniff`, `X-Frame-Options DENY` or `frame-ancestors`, HSTS when TLS terminates here.
+- A real `Content-Security-Policy` with explicit directives, `object-src 'none'`, `base-uri 'self'`, `frame-ancestors`; rolled out as `Content-Security-Policy-Report-Only` first, then enforced.
+- LF line endings (`nginx-no-crlf`): a CRLF config fails `nginx -t` with a nonsensical error.
+- A WAF (ModSecurity + OWASP CRS) in front of anything public, DetectionOnly first (`waf-rollout` skill, `modsecurity-tuning` rule).
+
+Never do:
+- An IP address as an upstream (`compose-no-hardcoded-ip` applies here too).
+- `'unsafe-inline'` or `'unsafe-eval'` in the CSP (`nginx-csp-no-unsafe`); use a nonce or a hash.
+- Logs to `/var/log/nginx/*.log`.
+</constraints>

package/packs/nginx/skills/waf-rollout/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: waf-rollout
+description: Use when a web app or API is about to be deployed or exposed publicly, or when asked whether to put a WAF in front of something. Decides and plans the ModSecurity + OWASP CRS rollout; the config detail is the modsecurity-tuning rule.
+---
+
+# waf-rollout
+
+One thing: decide the WAF and plan its rollout, once, when something goes public.
+
+<constraints>
+Always do:
+1. Raise it once, with the reason: a public endpoint with no WAF is the common failure, not a misconfiguration. Defense in depth: it sits on top of input validation (`schema-single-source-of-truth`), safe queries (`mongo` pack) and CSP, never instead of them.
+2. Recommend ModSecurity + OWASP CRS at the nginx layer (a managed WAF if there is no proxy).
+3. Plan: DetectionOnly for 2 to 4 weeks → review the audit log → targeted exclusions for false positives → flip to blocking. Tune the rule set to the stack (Node + MongoDB: NoSQL-injection rules in, PHP/Java/IIS files out).
+4. Hand the config work to the `modsecurity-tuning` rule, which loads on the config files themselves.
+
+Never do:
+- Ship blocking mode on day one.
+- Present the WAF as the security story.
+</constraints>

package/packs/python/checks/py-no-bare-except.json

@@ -0,0 +1,18 @@
+{
+  "id": "py-no-bare-except",
+  "why": "A bare except also catches KeyboardInterrupt and SystemExit, and hides every bug in the block. Catch the exception you expect, by name.",
+  "rule": ".claude/rules/python-errors-and-resources.md",
+  "concepts": [
+    "python"
+  ],
+  "globs": [],
+  "exclude": [
+    "**/node_modules/**",
+    "**/.venv/**",
+    "**/venv/**"
+  ],
+  "pattern": "^\\s*except\\s*:",
+  "flags": "m",
+  "bad": "try:\n    run()\nexcept:\n    log()",
+  "good": "try:\n    run()\nexcept ValueError:\n    log()"
+}

package/packs/python/checks/py-no-eval.json

@@ -0,0 +1,18 @@
+{
+  "id": "py-no-eval",
+  "why": "eval and exec run whatever text they are given.",
+  "rule": ".claude/rules/python-errors-and-resources.md",
+  "concepts": [
+    "python"
+  ],
+  "globs": [],
+  "exclude": [
+    "**/node_modules/**",
+    "**/.venv/**",
+    "**/venv/**"
+  ],
+  "pattern": "^[^#\\n]*(?<![\\w.])(?:eval|exec)\\(",
+  "flags": "m",
+  "bad": "value = eval(text)",
+  "good": "value = json.loads(text)\nmodel.eval()"
+}

package/packs/python/checks/py-no-mutable-default.json

@@ -0,0 +1,18 @@
+{
+  "id": "py-no-mutable-default",
+  "why": "A mutable default is made once and shared by every call, so one call changes the next.",
+  "rule": ".claude/rules/python-errors-and-resources.md",
+  "concepts": [
+    "python"
+  ],
+  "globs": [],
+  "exclude": [
+    "**/node_modules/**",
+    "**/.venv/**",
+    "**/venv/**"
+  ],
+  "pattern": "^\\s*(?:async\\s+)?def\\s+\\w+\\([^)]*=\\s*(?:\\[\\s*\\]|\\{\\s*\\}|set\\(\\)|dict\\(\\)|list\\(\\))",
+  "flags": "m",
+  "bad": "def add(row, rows=[]):\n    rows.append(row)",
+  "good": "def add(row, rows=None):\n    rows = rows or []"
+}

package/packs/python/checks/py-no-shell-true.json

@@ -0,0 +1,18 @@
+{
+  "id": "py-no-shell-true",
+  "why": "shell=True hands a string to a shell, so any value in it can run a command. Pass a list of arguments.",
+  "rule": ".claude/rules/python-errors-and-resources.md",
+  "concepts": [
+    "python"
+  ],
+  "globs": [],
+  "exclude": [
+    "**/node_modules/**",
+    "**/.venv/**",
+    "**/venv/**"
+  ],
+  "pattern": "\\bsubprocess\\.\\w+\\([^)\\n]*\\bshell\\s*=\\s*True",
+  "flags": "m",
+  "bad": "subprocess.run(f\"ls {path}\", shell=True)",
+  "good": "subprocess.run([\"ls\", path], check=True)"
+}

package/packs/python/checks/py-no-star-import.json

@@ -0,0 +1,18 @@
+{
+  "id": "py-no-star-import",
+  "why": "A star import hides where a name came from, and any new name in that module can silently replace one of yours.",
+  "rule": ".claude/rules/python-errors-and-resources.md",
+  "concepts": [
+    "python"
+  ],
+  "globs": [],
+  "exclude": [
+    "**/node_modules/**",
+    "**/.venv/**",
+    "**/venv/**"
+  ],
+  "pattern": "^from\\s+\\S+\\s+import\\s+\\*",
+  "flags": "m",
+  "bad": "from helpers import *",
+  "good": "from helpers import load, save"
+}

package/packs/python/checks/py-no-swallowed-exception.json

@@ -0,0 +1,18 @@
+{
+  "id": "py-no-swallowed-exception",
+  "why": "An exception caught and dropped is a failure nobody will ever see. Handle it, log it, or let it rise.",
+  "rule": ".claude/rules/python-errors-and-resources.md",
+  "concepts": [
+    "python"
+  ],
+  "globs": [],
+  "exclude": [
+    "**/node_modules/**",
+    "**/.venv/**",
+    "**/venv/**"
+  ],
+  "pattern": "^\\s*except\\b[^\\n]*:\\s*(?:#[^\\n]*)?\\n\\s*pass\\b|^\\s*except\\b(?:\\s+\\(?(?:Exception|BaseException)\\b[^\\n:]*)?:[ \\t]*(?:pass|continue|return\\b(?:[ \\t]+(?:None|True|False|0|1|\\[\\]|\\{\\}|\"\"|''))?)[ \\t]*(?:#[^\\n]*)?$",
+  "flags": "m",
+  "bad": "try:\n    run()\nexcept ValueError:\n    pass\ntry:\n    run()\nexcept Exception: return 0",
+  "good": "try:\n    run()\nexcept ValueError as e:\n    log.warning(e)\ntry:\n    run()\nexcept FileNotFoundError: return None"
+}

package/packs/python/checks/py-none-by-is.json

@@ -0,0 +1,18 @@
+{
+  "id": "py-none-by-is",
+  "why": "`== None` calls __eq__, which a class can change. `is None` asks the real question.",
+  "rule": ".claude/rules/python-errors-and-resources.md",
+  "concepts": [
+    "python"
+  ],
+  "globs": [],
+  "exclude": [
+    "**/node_modules/**",
+    "**/.venv/**",
+    "**/venv/**"
+  ],
+  "pattern": "^[^#\\n]*[=!]=\\s*None\\b",
+  "flags": "m",
+  "bad": "if value == None:\n    run()",
+  "good": "if value is None:\n    run()"
+}

package/packs/python/checks/py-open-with-with.json

@@ -0,0 +1,18 @@
+{
+  "id": "py-open-with-with",
+  "why": "A file opened without `with` stays open when anything raises.",
+  "rule": ".claude/rules/python-errors-and-resources.md",
+  "concepts": [
+    "python"
+  ],
+  "globs": [],
+  "exclude": [
+    "**/node_modules/**",
+    "**/.venv/**",
+    "**/venv/**"
+  ],
+  "pattern": "^\\s*\\w+\\s*=\\s*open\\(|^(?!\\s*with\\b)[^#\\n]*\\b(?:json\\.load\\(\\s*open\\(|open\\([^\\n]*\\)\\s*\\.\\s*(?:read|readlines|write)\\()",
+  "flags": "m",
+  "bad": "f = open(path)\ndata = f.read()\nrows = json.load(open(path))",
+  "good": "with open(path) as f:\n    data = f.read()"
+}

package/packs/python/checks/py-requests-timeout.json

@@ -0,0 +1,18 @@
+{
+  "id": "py-requests-timeout",
+  "why": "requests waits forever by default: one slow server hangs the program.",
+  "rule": ".claude/rules/python-errors-and-resources.md",
+  "concepts": [
+    "python"
+  ],
+  "globs": [],
+  "exclude": [
+    "**/node_modules/**",
+    "**/.venv/**",
+    "**/venv/**"
+  ],
+  "pattern": "\\brequests\\.(?:get|post|put|patch|delete|head)\\((?![^)\\n]*\\btimeout\\s*=)",
+  "flags": "m",
+  "bad": "r = requests.get(url)",
+  "good": "r = requests.get(url, timeout=10)"
+}

package/packs/python/checks/py-subprocess-output-checked.json

@@ -0,0 +1,18 @@
+{
+  "id": "py-subprocess-output-checked",
+  "why": "Reading .stdout straight off subprocess.run loses the return code, so a failed tool looks like an empty result and a gate goes green. A tool's failure and nothing to report must never give the same output.",
+  "rule": ".claude/rules/python-errors-and-resources.md",
+  "concepts": [
+    "python"
+  ],
+  "globs": [],
+  "exclude": [
+    "**/node_modules/**",
+    "**/.venv/**",
+    "**/venv/**"
+  ],
+  "pattern": "^[^#\\n]*\\bsubprocess\\.run\\((?![^\\n]*\\bcheck\\s*=\\s*True)[^\\n]*\\)\\s*\\.\\s*(?:stdout|stderr)\\b",
+  "flags": "m",
+  "bad": "names = subprocess.run([\"git\", \"diff\"], capture_output=True, text=True).stdout.split()",
+  "good": "names = subprocess.run([\"git\", \"diff\"], capture_output=True, text=True, check=True).stdout.split()\nr = subprocess.run(cmd)\nif r.returncode:\n    fail()"
+}

package/packs/python/checks/py-yaml-safe-load.json

@@ -0,0 +1,18 @@
+{
+  "id": "py-yaml-safe-load",
+  "why": "yaml.load can build arbitrary objects from the text it reads.",
+  "rule": ".claude/rules/python-errors-and-resources.md",
+  "concepts": [
+    "python"
+  ],
+  "globs": [],
+  "exclude": [
+    "**/node_modules/**",
+    "**/.venv/**",
+    "**/venv/**"
+  ],
+  "pattern": "\\byaml\\.load\\((?![^)\\n]*Loader\\s*=\\s*yaml\\.SafeLoader)",
+  "flags": "m",
+  "bad": "data = yaml.load(text)",
+  "good": "data = yaml.safe_load(text)"
+}

package/packs/python/pack.json

@@ -0,0 +1,26 @@
+{
+  "name": "python",
+  "version": "1.0.0",
+  "description": "Python projects: what is repeated becomes a template in the forms Python has for it, errors are handled where they can be, resources are closed, subprocess and network calls are safe.",
+  "type": "stock",
+  "author": "claude-packs",
+  "license": "MIT",
+  "homepage": "https://github.com/TheDecipherist/claude-packs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TheDecipherist/claude-packs.git",
+    "directory": "packs/python"
+  },
+  "keywords": [
+    "python"
+  ],
+  "engines": {
+    "claude-packs": ">=0.25.0"
+  },
+  "concepts": {
+    "python": [
+      "**/*.py",
+      "**/*.pyi"
+    ]
+  }
+}

package/packs/python/rules/python-errors-and-resources.md

@@ -0,0 +1,26 @@
+---
+# concepts: python
+paths:
+  - "placeholder"
+---
+
+# Errors are handled where something can be done; every resource closes itself
+
+<constraints>
+Always do:
+- Catch the exception you expect, by name, where something can be done about it. Otherwise let it rise.
+- Open files, sockets and locks with `with`.
+- Give every network call a timeout.
+- Pass `subprocess` a list of arguments, with `check=True` or a read of its return code: a tool's failure and "nothing to report" must never give the same output.
+- Compare with `None` by `is`.
+- Default a mutable argument to `None` and build it in the function.
+- Load YAML with `yaml.safe_load`.
+
+Never do:
+- Write a bare `except:`, or `except ...: pass`.
+- Use `shell=True`, `eval` or `exec` on text that came from outside.
+- Import with `*`.
+</constraints>
+
+## Check
+`py-no-bare-except`, `py-subprocess-output-checked`, `py-no-swallowed-exception`, `py-no-mutable-default`, `py-no-shell-true`, `py-open-with-with`, `py-none-by-is`, `py-no-eval`, `py-no-star-import`, `py-requests-timeout`, `py-yaml-safe-load`.

package/packs/python/rules/python-repeats-become-templates.md

@@ -0,0 +1,27 @@
+---
+# concepts: python
+paths:
+  - "placeholder"
+---
+
+# Anything repeated in Python becomes a template: pick the form that fits the repeat
+
+<constraints>
+Always do:
+- Match the repeat to its form:
+  - A block with the same statements and other names: one function, with what differs as its parameters. `template-law` and `scan` list what differs.
+  - The same set-up and tear-down around different work: a context manager.
+  - The same wrapping around many functions (retry, timing, logging): a decorator.
+  - The same fields passed around together: a `dataclass`.
+  - One call repeated with other arguments: a list of rows and one loop.
+  - Classes alike except for a few values: class attributes on one base class. Except for a few methods: a base class or a `Protocol`, each kind holding only what is its own.
+  - A script copied to start the next one: one module both import, with `if __name__ == "__main__":` in each.
+- Keep shared code in a package the scripts import, not beside them.
+
+Never do:
+- Copy a file to change a few lines, or keep a package and a loose copy of the same module side by side.
+- Add a flag parameter to merge two things that are different.
+</constraints>
+
+## Check
+`template-law` refuses a new copy, a near copy, or a function the repo already has. The `python-extract-template` skill walks the change.