pywrit 0.2.4__tar.gz → 0.2.5__tar.gz

{pywrit-0.2.4 → pywrit-0.2.5}/PKG-INFO

@@ -1,15 +1,23 @@
 Metadata-Version: 2.4
 Name: pywrit
-Version: 0.2.4
+Version: 0.2.5
 Summary: Python client + CLI for Writ — the gate before the write
 License: MIT
 Project-URL: Homepage, https://github.com/AvenueDAdmin/pywrit
 Project-URL: Documentation, https://withwrit.com/docs
-Keywords: ai-agents,policy,audit-log,guardrails
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: httpx>=0.27
+Provides-Extra: polyglot
+Requires-Dist: tree-sitter>=0.23; extra == "polyglot"
+Requires-Dist: tree-sitter-typescript>=0.23; extra == "polyglot"
+Requires-Dist: tree-sitter-javascript>=0.23; extra == "polyglot"
+Provides-Extra: keywords
+Requires-Dist: ai-agents; extra == "keywords"
+Requires-Dist: policy; extra == "keywords"
+Requires-Dist: audit-log; extra == "keywords"
+Requires-Dist: guardrails; extra == "keywords"
 Dynamic: license-file
 
 # pywrit
@@ -114,13 +122,25 @@ Python (`.py`) files, parsed with the stdlib `ast` (no extra dependencies):
   calls such as `stripe.Refund.create(...)`, deferred task queues, or shared clients
   several layers down. The risk report lists these gaps every time.
 
-### TypeScript / JavaScript: coming soon (not yet released)
+### TypeScript / JavaScript (scan-only)
 
-> **Not available in `pywrit` 0.2.2 or on PyPI yet.** The current release scans
-> Python only. The preview below shows scan-only TS/JS support that is still in
-> development; the command it uses is not available yet.
+`writ scan` also finds write sites in TypeScript and JavaScript. It needs the
+optional extra (tree-sitter based):
 
-![Preview, not yet released: writ scan on a TypeScript agent finds 5 write sites, 1 of 5 gated](https://raw.githubusercontent.com/AvenueDAdmin/pywrit/main/docs/assets/scan-tsjs.gif)
+    pip install 'pywrit[polyglot]'
+    writ scan .
+
+Without the extra, the scanner prints a one-line hint and keeps going —
+Python scanning never needs it.
+
+TS/JS is **scan-only**: findings are listed with verbs for your policy file,
+but `writ scan --apply` never rewrites TS/JS files — gate those by hand.
+Covered patterns: `fetch`/`axios` writes, `fs` writes, SQL through knex-style
+clients, Prisma writes, and JS SDK calls such as `stripe.refunds.create(...)`.
+(Still not covered: the *Python* SDK equivalents like `stripe.Refund.create(...)`
+— see "Not covered" above.)
+
+![writ scan on a TypeScript agent finds 5 write sites, 1 of 5 gated](https://raw.githubusercontent.com/AvenueDAdmin/pywrit/main/docs/assets/scan-tsjs.gif)
 
 ## Python client
 

pywrit-0.2.4/src/pywrit.egg-info/PKG-INFO → pywrit-0.2.5/README.md

@@ -1,17 +1,3 @@
-Metadata-Version: 2.4
-Name: pywrit
-Version: 0.2.4
-Summary: Python client + CLI for Writ — the gate before the write
-License: MIT
-Project-URL: Homepage, https://github.com/AvenueDAdmin/pywrit
-Project-URL: Documentation, https://withwrit.com/docs
-Keywords: ai-agents,policy,audit-log,guardrails
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: httpx>=0.27
-Dynamic: license-file
-
 # pywrit
 
 **Find the dangerous writes in your Python agent's code, then gate it.** `pywrit` is the Python
@@ -114,13 +100,25 @@ Python (`.py`) files, parsed with the stdlib `ast` (no extra dependencies):
   calls such as `stripe.Refund.create(...)`, deferred task queues, or shared clients
   several layers down. The risk report lists these gaps every time.
 
-### TypeScript / JavaScript: coming soon (not yet released)
+### TypeScript / JavaScript (scan-only)
+
+`writ scan` also finds write sites in TypeScript and JavaScript. It needs the
+optional extra (tree-sitter based):
+
+    pip install 'pywrit[polyglot]'
+    writ scan .
+
+Without the extra, the scanner prints a one-line hint and keeps going —
+Python scanning never needs it.
 
-> **Not available in `pywrit` 0.2.2 or on PyPI yet.** The current release scans
-> Python only. The preview below shows scan-only TS/JS support that is still in
-> development; the command it uses is not available yet.
+TS/JS is **scan-only**: findings are listed with verbs for your policy file,
+but `writ scan --apply` never rewrites TS/JS files — gate those by hand.
+Covered patterns: `fetch`/`axios` writes, `fs` writes, SQL through knex-style
+clients, Prisma writes, and JS SDK calls such as `stripe.refunds.create(...)`.
+(Still not covered: the *Python* SDK equivalents like `stripe.Refund.create(...)`
+— see "Not covered" above.)
 
-![Preview, not yet released: writ scan on a TypeScript agent finds 5 write sites, 1 of 5 gated](https://raw.githubusercontent.com/AvenueDAdmin/pywrit/main/docs/assets/scan-tsjs.gif)
+![writ scan on a TypeScript agent finds 5 write sites, 1 of 5 gated](https://raw.githubusercontent.com/AvenueDAdmin/pywrit/main/docs/assets/scan-tsjs.gif)
 
 ## Python client
 

{pywrit-0.2.4 → pywrit-0.2.5}/pyproject.toml

@@ -4,12 +4,21 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pywrit"
-version = "0.2.4"
+version = "0.2.5"
 description = "Python client + CLI for Writ — the gate before the write"
 readme = "README.md"
 license = { text = "MIT" }
 requires-python = ">=3.9"
 dependencies = ["httpx>=0.27"]
+
+[project.optional-dependencies]
+# `pip install 'pywrit[polyglot]'`: lets `writ scan` parse TypeScript and
+# JavaScript (scan only). Python scanning never needs it.
+polyglot = [
+    "tree-sitter>=0.23",
+    "tree-sitter-typescript>=0.23",
+    "tree-sitter-javascript>=0.23",
+]
 keywords = ["ai-agents", "policy", "audit-log", "guardrails"]
 
 [project.urls]

{pywrit-0.2.4 → pywrit-0.2.5}/src/pywrit/__init__.py

@@ -27,7 +27,7 @@ from .errors import (
     WritError,
 )
 
-__version__ = "0.2.4"
+__version__ = "0.2.5"
 
 __all__ = [
     "WritClient",

{pywrit-0.2.4 → pywrit-0.2.5}/src/pywrit/cli.py

@@ -610,6 +610,468 @@ def _apply_edits(lines, edits):
     return out
 
 
+# ---------------------------------------------------------------------------
+# writ scan, TypeScript/JavaScript: deterministic and scan-only (TS/JS files
+# are never rewritten). Parsing needs the optional extra
+# `pip install 'pywrit[polyglot]'` (tree-sitter); without it the scanner
+# prints a one-line hint and keeps going. Rules are data (_TSJS_RULES) so
+# other languages can reuse the same (id, kind, callee patterns, condition)
+# shape.
+# ---------------------------------------------------------------------------
+import re as _re
+import subprocess as _subprocess
+
+_TSJS_EXTS = {".ts": "typescript", ".tsx": "tsx", ".js": "javascript",
+              ".jsx": "javascript", ".mjs": "javascript", ".cjs": "javascript"}
+_TSJS_SKIP_DIR_NAMES = _SKIP_DIR_NAMES | {".next", "vendor", "venv", ".venv"}
+_TSJS_TEST_DIRS = {"tests", "testing", "__tests__"}
+_TSJS_MAX_BYTES = 1000000  # larger files are almost always bundles
+_TSJS_HINT = ("hint: %d TS/JS file(s) not scanned; install the extra: "
+              "pip install 'pywrit[polyglot]'")
+_TSJS_WRITE_METHODS = {"post", "put", "patch", "delete"}
+_TSJS_SQL_WRITE = _re.compile(
+    r"^\s*\(*\s*(insert|update|delete|drop|alter|truncate|create|replace|"
+    r"merge)\b", _re.I)
+_TSJS_GATE_NAMES = {"writ_check", "_writ_check", "writcheck"}
+
+# import/require source -> canonical callee prefix
+_TSJS_MODULES = {
+    "fs": ("fs",), "fs/promises": ("fs", "promises"), "fs-extra": ("fs",),
+    "graceful-fs": ("fs",), "child_process": ("child_process",),
+    "http": ("http",), "https": ("https",), "axios": ("axios",),
+    "got": ("got",), "ky": ("ky",), "superagent": ("superagent",),
+    "node-fetch": ("fetch",), "cross-fetch": ("fetch",),
+    "isomorphic-fetch": ("fetch",), "knex": ("knex",), "stripe": ("stripe",),
+}
+
+_FS_FNS = ("writeFile", "appendFile", "unlink", "rm", "rmdir", "rename",
+           "mkdir", "copyFile", "cp", "truncate", "symlink")
+_TSJS_FS = "|".join(_FS_FNS + tuple(f + "Sync" for f in _FS_FNS)
+                    + ("createWriteStream",))
+_TSJS_DB_HINTS = "|".join(sorted(_DB_HINTS | {"knex", "trx", "pool"}))
+_TSJS_DB_METHODS = ("insert|update|del|delete|upsert|truncate|save|remove|"
+                    "insertOne|insertMany|updateOne|updateMany|deleteOne|"
+                    "deleteMany|replaceOne|bulkWrite")
+_TSJS_HTTP_HINTS = "|".join(sorted(_HTTP_HINTS | {"httpclient", "$http",
+                                                  "request", "agent"}))
+_TSJS_HTTP_VERBS = "post|put|patch|delete|del"
+
+# (rule id, kind, callee patterns, condition). First match wins.
+# Patterns are dotted callee chains (after import aliasing and dropping a
+# leading `this`): `a|b` alternatives, `*` one segment, `**` any segments.
+# Conditions: None, "method" (a literal write method in an options object
+# or as a leading string arg), "sql" (first arg is a literal SQL write).
+_TSJS_RULES = (
+    ("child-process", "exec",
+     ("child_process.exec|execSync|execFile|execFileSync|spawn|spawnSync|"
+      "fork",), None),
+    ("fs-write", "file",
+     ("fs." + _TSJS_FS, "fs.promises." + _TSJS_FS), None),
+    ("sql-write", "db",
+     ("**.query|execute|raw|exec|run|unsafe|$executeRaw|$executeRawUnsafe|"
+      "$queryRaw|$queryRawUnsafe|sql",), "sql"),
+    ("stripe-write", "sdk",
+     ("stripe.**.create|update|del|cancel|capture|confirm|pay",), None),
+    ("prisma-write", "db",
+     ("prisma.*.create|createMany|update|updateMany|upsert|delete|deleteMany",),
+     None),
+    ("db-write", "db",
+     ("%s.**.%s" % (_TSJS_DB_HINTS, _TSJS_DB_METHODS),
+      "**.%s.%s" % (_TSJS_DB_HINTS, _TSJS_DB_METHODS)), None),
+    ("fetch-write", "http",
+     ("fetch", "window|globalThis|self.fetch"), "method"),
+    ("http-client-write", "http",
+     ("axios|got|ky|superagent.**." + _TSJS_HTTP_VERBS,
+      "**.%s.%s" % (_TSJS_HTTP_HINTS, _TSJS_HTTP_VERBS)), None),
+    ("http-config-write", "http",
+     ("axios|got|ky|superagent", "axios|got|ky.request",
+      "http|https.request"), "method"),
+)
+
+
+def _tsjs_compile(pattern):
+    return tuple(s if s in ("*", "**") else
+                 frozenset(a.lower() for a in s.split("|"))
+                 for s in pattern.split("."))
+
+
+_TSJS_COMPILED = tuple((rid, kind, tuple(_tsjs_compile(p) for p in pats), cond)
+                       for rid, kind, pats, cond in _TSJS_RULES)
+
+
+def _tsjs_glob(segs, chain):
+    if not segs:
+        return not chain
+    s = segs[0]
+    if s == "**":
+        return any(_tsjs_glob(segs[1:], chain[i:])
+                   for i in range(len(chain) + 1))
+    if not chain or (s != "*" and chain[0] not in s):
+        return False
+    return _tsjs_glob(segs[1:], chain[1:])
+
+
+def _tsjs_parsers():
+    """Return {grammar: Parser}, or {} when the polyglot extra is missing."""
+    try:
+        import tree_sitter as ts
+    except ImportError:
+        return {}
+    try:
+        import tree_sitter_typescript as tst
+        import tree_sitter_javascript as tsj
+        fns = {"typescript": tst.language_typescript,
+               "tsx": tst.language_tsx, "javascript": tsj.language}
+    except ImportError:
+        try:
+            from tree_sitter_language_pack import get_language
+        except ImportError:
+            return {}
+        fns = {k: (lambda k=k: get_language(k))
+               for k in ("typescript", "tsx", "javascript")}
+    parsers = {}
+    try:
+        for name, fn in fns.items():
+            lang = fn()
+            if not isinstance(lang, ts.Language):
+                lang = ts.Language(lang)
+            try:
+                parser = ts.Parser(lang)
+            except TypeError:
+                parser = ts.Parser()
+                parser.language = lang
+            parsers[name] = parser
+    except Exception:
+        return {}
+    return parsers
+
+
+def _tsjs_should_skip(path, root, excludes):
+    rel = path.relative_to(root)
+    if any(p in _TSJS_SKIP_DIR_NAMES or p.startswith(".")
+           for p in rel.parts[:-1]):
+        return True
+    if any(p in _TSJS_TEST_DIRS for p in rel.parts[:-1]):
+        return True
+    name = path.name
+    if ".test." in name or ".spec." in name or name.endswith(
+            (".d.ts", ".min.js")):
+        return True
+    s = str(path)
+    return any(e in s for e in excludes)
+
+
+def _tsjs_git_files(root):
+    """Tracked + untracked-not-ignored files under root, or None."""
+    try:
+        out = _subprocess.run(
+            ["git", "-C", str(root), "ls-files", "-co", "--exclude-standard",
+             "-z"], stdout=_subprocess.PIPE, stderr=_subprocess.DEVNULL,
+            timeout=60, check=False)
+    except (OSError, _subprocess.SubprocessError):
+        return None
+    if out.returncode != 0:
+        return None
+    return [r for r in out.stdout.decode("utf-8", "replace").split("\0") if r]
+
+
+def _tsjs_collect_files(root, excludes):
+    rels = _tsjs_git_files(root)
+    if rels is None:
+        rels = []
+        for dp, dns, fns in os.walk(str(root)):
+            dns[:] = [d for d in dns if d not in _TSJS_SKIP_DIR_NAMES
+                      and not d.startswith(".")]
+            rels.extend(os.path.relpath(os.path.join(dp, f), str(root))
+                        for f in fns)
+    out = set()
+    for r in rels:
+        p = root / r
+        if p.suffix in _TSJS_EXTS and not _tsjs_should_skip(p, root, excludes) \
+                and p.is_file():
+            out.add(p)
+    return sorted(out)
+
+
+_TSJS_FUNC_TYPES = {"function_declaration", "generator_function_declaration",
+                    "function_expression", "function", "generator_function",
+                    "arrow_function", "method_definition"}
+_TSJS_CLASS_TYPES = {"class_declaration", "class",
+                     "abstract_class_declaration"}
+_TSJS_UNWRAP = {"parenthesized_expression", "await_expression",
+                "non_null_expression", "as_expression",
+                "satisfies_expression", "type_assertion"}
+
+
+class _TsjsFile:
+    def __init__(self, src):
+        self.src = src
+
+    def text(self, node):
+        return self.src[node.start_byte:node.end_byte].decode("utf-8",
+                                                              "replace")
+
+    def literal(self, node):
+        """String value of a string/template literal node, else None."""
+        if node is None:
+            return None
+        if node.type == "string":
+            return self.text(node)[1:-1]
+        if node.type == "template_string":
+            return self.text(node)[1:-1]  # substitutions stay as ${...}
+        return None
+
+    def chain(self, node):
+        """Dotted callee chain, e.g. knex("t").where().del -> [knex(), where(), del]."""
+        while node is not None and node.type in _TSJS_UNWRAP:
+            kids = node.named_children
+            node = kids[-1] if node.type == "await_expression" and kids \
+                else (kids[0] if kids else None)
+        if node is None:
+            return ["?"]
+        t = node.type
+        if t in ("identifier", "property_identifier",
+                 "private_property_identifier", "shorthand_property_identifier"):
+            return [self.text(node)]
+        if t == "this":
+            return ["this"]
+        if t == "member_expression":
+            prop = node.child_by_field_name("property")
+            return self.chain(node.child_by_field_name("object")) + \
+                [self.text(prop) if prop is not None else "?"]
+        if t == "call_expression":
+            c = self.chain(node.child_by_field_name("function"))
+            c[-1] = c[-1] + "()"
+            return c
+        return ["?"]
+
+
+def _tsjs_func_name(node, f):
+    name = node.child_by_field_name("name")
+    if name is not None and node.type != "arrow_function":
+        return f.text(name)
+    parent = node.parent
+    if parent is None:
+        return None
+    pt = parent.type
+    if pt == "variable_declarator":
+        n = parent.child_by_field_name("name")
+        return f.text(n) if n is not None and n.type == "identifier" else None
+    if pt == "pair":
+        k = parent.child_by_field_name("key")
+        return (f.literal(k) or f.text(k)) if k is not None else None
+    if pt == "assignment_expression":
+        left = parent.child_by_field_name("left")
+        if left is not None and left.type == "member_expression":
+            left = left.child_by_field_name("property")
+        return f.text(left) if left is not None else None
+    if pt in ("public_field_definition", "field_definition"):
+        n = parent.child_by_field_name("name") or \
+            parent.child_by_field_name("property")
+        return f.text(n) if n is not None else None
+    return None
+
+
+def _tsjs_module_prefix(source):
+    if source is None:
+        return None
+    if source.startswith("node:"):
+        source = source[5:]
+    return _TSJS_MODULES.get(source)
+
+
+def _tsjs_record_import(node, f, aliases):
+    src = node.child_by_field_name("source")
+    prefix = _tsjs_module_prefix(f.literal(src))
+    if prefix is None:
+        return
+    for clause in node.named_children:
+        if clause.type != "import_clause":
+            continue
+        for part in clause.named_children:
+            if part.type == "identifier":  # default import
+                aliases[f.text(part)] = prefix
+            elif part.type == "namespace_import":
+                ids = [c for c in part.named_children if c.type == "identifier"]
+                if ids:
+                    aliases[f.text(ids[-1])] = prefix
+            elif part.type == "named_imports":
+                for spec in part.named_children:
+                    if spec.type != "import_specifier":
+                        continue
+                    ids = [c for c in spec.named_children
+                           if c.type in ("identifier", "string")]
+                    if not ids:
+                        continue
+                    imported = f.literal(ids[0]) or f.text(ids[0])
+                    local = f.text(ids[-1])
+                    if imported == "default":
+                        aliases[local] = prefix
+                    else:
+                        aliases[local] = prefix + (imported,)
+
+
+def _tsjs_record_require(node, f, aliases):
+    """const x = require("m") / const {a, b: c} = require("m") / .prop"""
+    value = node.child_by_field_name("value")
+    extra = ()
+    if value is not None and value.type == "member_expression":
+        prop = value.child_by_field_name("property")
+        extra = (f.text(prop),) if prop is not None else ()
+        value = value.child_by_field_name("object")
+    if value is None or value.type != "call_expression":
+        return
+    fn = value.child_by_field_name("function")
+    if fn is None or f.text(fn) != "require":
+        return
+    args = value.child_by_field_name("arguments")
+    first = args.named_children[0] if args is not None and \
+        args.named_children else None
+    prefix = _tsjs_module_prefix(f.literal(first))
+    if prefix is None:
+        return
+    prefix = prefix + extra
+    name = node.child_by_field_name("name")
+    if name is None:
+        return
+    if name.type == "identifier":
+        aliases[f.text(name)] = prefix
+    elif name.type == "object_pattern":
+        for p in name.named_children:
+            if p.type == "shorthand_property_identifier_pattern":
+                aliases[f.text(p)] = prefix + (f.text(p),)
+            elif p.type == "pair_pattern":
+                k = p.child_by_field_name("key")
+                v = p.child_by_field_name("value")
+                if k is not None and v is not None and v.type == "identifier":
+                    aliases[f.text(v)] = prefix + (f.text(k),)
+
+
+def _tsjs_args(call):
+    args = call.child_by_field_name("arguments")
+    if args is None:
+        return []
+    if args.type == "template_string":  # tagged template: sql`...`
+        return [args]
+    return [a for a in args.named_children if a.type != "comment"]
+
+
+def _tsjs_has_write_method(call, f):
+    for a in _tsjs_args(call)[:2]:
+        lit = f.literal(a)
+        if lit is not None and lit.lower() in _TSJS_WRITE_METHODS:
+            return True
+        if a.type != "object":
+            continue
+        for pair in a.named_children:
+            if pair.type != "pair":
+                continue
+            k = pair.child_by_field_name("key")
+            key = (f.literal(k) or f.text(k)) if k is not None else ""
+            if key != "method":
+                continue
+            v = f.literal(pair.child_by_field_name("value"))
+            if v is not None and v.lower() in _TSJS_WRITE_METHODS:
+                return True
+    return False
+
+
+def _tsjs_classify(call, chain, f):
+    for rid, kind, pats, cond in _TSJS_COMPILED:
+        if not any(_tsjs_glob(p, chain) for p in pats):
+            continue
+        if cond == "method" and not _tsjs_has_write_method(call, f):
+            continue
+        if cond == "sql":
+            args = _tsjs_args(call)
+            lit = f.literal(args[0]) if args else None
+            if lit is None or not _TSJS_SQL_WRITE.match(lit):
+                continue
+        return rid, kind
+    return None
+
+
+def _tsjs_scan_source(src, filename, parser):
+    """Return (sites, gated) where sites = [(_WriteSite, rule_id)] and
+    gated = {(func_name, func_line)}. Module-level writes use func ""."""
+    f = _TsjsFile(src)
+    tree = parser.parse(src)
+    aliases, calls, gated = {}, [], set()
+    stack = [(tree.root_node, ("", 0), "")]
+    while stack:
+        node, fkey, cls = stack.pop()
+        t = node.type
+        if t in _TSJS_FUNC_TYPES:
+            name = _tsjs_func_name(node, f)
+            if name:
+                fkey = (name, node.start_point[0] + 1)
+        elif t in _TSJS_CLASS_TYPES:
+            n = node.child_by_field_name("name")
+            cls = f.text(n) if n is not None else cls
+        elif t == "import_statement":
+            _tsjs_record_import(node, f, aliases)
+        elif t == "variable_declarator":
+            _tsjs_record_require(node, f, aliases)
+        elif t == "call_expression":
+            calls.append((node, fkey, cls))
+        stack.extend((c, fkey, cls) for c in reversed(node.children))
+    sites = []
+    for node, fkey, cls in calls:
+        raw = f.chain(node.child_by_field_name("function"))
+        chain = [c[:-2] if c.endswith("()") else c for c in raw]
+        if chain and chain[0] == "this":
+            chain = chain[1:]
+        if chain and chain[0] in aliases:
+            chain = list(aliases[chain[0]]) + chain[1:]
+        chain = [c.lower() for c in chain]
+        if not chain:
+            continue
+        if chain[-1] in _TSJS_GATE_NAMES:
+            gated.add(fkey)
+            continue
+        hit = _tsjs_classify(node, chain, f)
+        if hit:
+            snippet = " ".join(f.text(node).split())[:100]
+            sites.append((_WriteSite(filename, fkey[0], cls,
+                                     node.start_point[0] + 1, hit[1], snippet),
+                          hit[0], fkey))
+    return sites, gated
+
+
+def _tsjs_verb(rel, func_name, cls_name, kind):
+    """infer_verb for TS/JS: camelCase names, `orders.service.ts` -> orders."""
+    snake = _re.sub(r"(?<=[a-z0-9])(?=[A-Z])", "_", func_name)
+    base = rel.with_name(rel.name.split(".")[0] + rel.suffix)
+    return infer_verb(base, snake, cls_name, kind)
+
+
+def _tsjs_scan(root, excludes):
+    """Return dict with files, skipped, sites, gated, or hint when the
+    extra is missing. Never raises on a bad file."""
+    files = _tsjs_collect_files(root, excludes)
+    res = {"files": files, "skipped": [], "sites": [], "gated": set(),
+           "missing_extra": False}
+    if not files:
+        return res
+    parsers = _tsjs_parsers()
+    if not parsers:
+        res["missing_extra"] = True
+        return res
+    for path in files:
+        try:
+            if path.stat().st_size > _TSJS_MAX_BYTES:
+                res["skipped"].append(str(path))
+                continue
+            src = path.read_bytes()
+            sites, gated = _tsjs_scan_source(
+                src, str(path), parsers[_TSJS_EXTS[path.suffix]])
+        except Exception:
+            res["skipped"].append(str(path))
+            continue
+        res["sites"].extend(sites)
+        res["gated"].update((str(path),) + g for g in gated)
+    return res
+
 def scan_cmd(args):
     import json as _json
     root = _pathlib.Path(args.path).resolve()
@@ -635,6 +1097,14 @@ def scan_cmd(args):
         sites.extend(v.sites)
         gated.update((str(path), n, ln) for (n, ln) in v.gated)
 
+    tsjs = _tsjs_scan(root, args.exclude or [])
+    ts_sites = tsjs["sites"]
+    ts_by_func = {}
+    for s, _rid, fkey in ts_sites:
+        ts_by_func.setdefault((s.file,) + fkey, []).append(s)
+    ts_gated = sum(1 for s, _rid, fkey in ts_sites
+                   if (s.file,) + fkey in tsjs["gated"])
+
     by_func = {}
     for s in sites:
         by_func.setdefault((s.file, s.func, s.cls), []).append(s)
@@ -649,6 +1119,10 @@ def scan_cmd(args):
         rel = _pathlib.Path(f).relative_to(root)
         verbs.setdefault(infer_verb(rel, func_name, cls_name, ss[0].kind),
                          "require_grant")
+    for (f, func_name, _ln), ss in sorted(ts_by_func.items()):
+        rel = _pathlib.Path(f).relative_to(root)
+        verbs.setdefault(_tsjs_verb(rel, func_name, ss[0].cls, ss[0].kind),
+                         "require_grant")
 
     if args.score:
         print_score_report(root, sites, gated_funcs)
@@ -658,6 +1132,22 @@ def scan_cmd(args):
     print("  files scanned: %d  skipped: %d" % (len(files), len(skipped)))
     print("  write sites: %d in %d function(s)" % (total, len(by_func)))
     print("  gated: %d/%d (%d%%)" % (gated_site_count, total, pct))
+    if tsjs["missing_extra"]:
+        print("  " + _TSJS_HINT % len(tsjs["files"]))
+    elif tsjs["files"]:
+        ts_total = len(ts_sites)
+        print("  ts/js files scanned: %d  skipped: %d  (scan only, no --apply)"
+              % (len(tsjs["files"]), len(tsjs["skipped"])))
+        print("  ts/js write sites: %d in %d function(s)"
+              % (ts_total, len(ts_by_func)))
+        print("  ts/js gated: %d/%d (%d%%)" % (
+            ts_gated, ts_total,
+            (100 * ts_gated // ts_total) if ts_total else 100))
+        for s, rid, _fkey in sorted(ts_sites, key=lambda x: (x[0].file,
+                                                             x[0].lineno)):
+            print("    %s:%d [%s] %s %s(): %s" % (
+                _pathlib.Path(s.file).relative_to(root), s.lineno, s.kind,
+                rid, s.func or "<module>", s.snippet))
     if verbs:
         print("  verbs discovered: %d" % len(verbs))
         for vname in sorted(verbs):
@@ -692,7 +1182,11 @@ def scan_cmd(args):
         print("  manual: %s %s() [%s]: %s" % (path, func_name, verb, why))
 
     if not results:
-        print("nothing to instrument.")
+        if ts_sites:
+            print("nothing to instrument (ts/js findings are scan-only; "
+                  "gate them by hand).")
+        else:
+            print("nothing to instrument.")
         return 0
 
     total_gates = sum(r[3] for r in results)

pywrit-0.2.4/README.md → pywrit-0.2.5/src/pywrit.egg-info/PKG-INFO

@@ -1,3 +1,25 @@
+Metadata-Version: 2.4
+Name: pywrit
+Version: 0.2.5
+Summary: Python client + CLI for Writ — the gate before the write
+License: MIT
+Project-URL: Homepage, https://github.com/AvenueDAdmin/pywrit
+Project-URL: Documentation, https://withwrit.com/docs
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.27
+Provides-Extra: polyglot
+Requires-Dist: tree-sitter>=0.23; extra == "polyglot"
+Requires-Dist: tree-sitter-typescript>=0.23; extra == "polyglot"
+Requires-Dist: tree-sitter-javascript>=0.23; extra == "polyglot"
+Provides-Extra: keywords
+Requires-Dist: ai-agents; extra == "keywords"
+Requires-Dist: policy; extra == "keywords"
+Requires-Dist: audit-log; extra == "keywords"
+Requires-Dist: guardrails; extra == "keywords"
+Dynamic: license-file
+
 # pywrit
 
 **Find the dangerous writes in your Python agent's code, then gate it.** `pywrit` is the Python
@@ -100,13 +122,25 @@ Python (`.py`) files, parsed with the stdlib `ast` (no extra dependencies):
   calls such as `stripe.Refund.create(...)`, deferred task queues, or shared clients
   several layers down. The risk report lists these gaps every time.
 
-### TypeScript / JavaScript: coming soon (not yet released)
+### TypeScript / JavaScript (scan-only)
+
+`writ scan` also finds write sites in TypeScript and JavaScript. It needs the
+optional extra (tree-sitter based):
+
+    pip install 'pywrit[polyglot]'
+    writ scan .
+
+Without the extra, the scanner prints a one-line hint and keeps going —
+Python scanning never needs it.
 
-> **Not available in `pywrit` 0.2.2 or on PyPI yet.** The current release scans
-> Python only. The preview below shows scan-only TS/JS support that is still in
-> development; the command it uses is not available yet.
+TS/JS is **scan-only**: findings are listed with verbs for your policy file,
+but `writ scan --apply` never rewrites TS/JS files — gate those by hand.
+Covered patterns: `fetch`/`axios` writes, `fs` writes, SQL through knex-style
+clients, Prisma writes, and JS SDK calls such as `stripe.refunds.create(...)`.
+(Still not covered: the *Python* SDK equivalents like `stripe.Refund.create(...)`
+— see "Not covered" above.)
 
-![Preview, not yet released: writ scan on a TypeScript agent finds 5 write sites, 1 of 5 gated](https://raw.githubusercontent.com/AvenueDAdmin/pywrit/main/docs/assets/scan-tsjs.gif)
+![writ scan on a TypeScript agent finds 5 write sites, 1 of 5 gated](https://raw.githubusercontent.com/AvenueDAdmin/pywrit/main/docs/assets/scan-tsjs.gif)
 
 ## Python client
 

{pywrit-0.2.4 → pywrit-0.2.5}/src/pywrit.egg-info/SOURCES.txt

@@ -11,4 +11,5 @@ src/pywrit.egg-info/dependency_links.txt
 src/pywrit.egg-info/entry_points.txt
 src/pywrit.egg-info/requires.txt
 src/pywrit.egg-info/top_level.txt
-tests/test_client.py
+tests/test_client.py
+tests/test_scan_tsjs.py

pywrit-0.2.5/src/pywrit.egg-info/requires.txt

@@ -0,0 +1,12 @@
+httpx>=0.27
+
+[keywords]
+ai-agents
+policy
+audit-log
+guardrails
+
+[polyglot]
+tree-sitter>=0.23
+tree-sitter-typescript>=0.23
+tree-sitter-javascript>=0.23

pywrit-0.2.5/tests/test_scan_tsjs.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+"""Deterministic tests for `writ scan` TypeScript/JavaScript support.
+
+Fixtures live in tests/fixtures/tsjs. Every line tagged `// expect: <rule>`
+must be reported with that rule, and nothing else may be reported.
+Tests that parse TS/JS skip when the optional `polyglot` extra
+(tree-sitter) is not installed; the rest run with zero extra deps.
+"""
+
+import argparse
+import contextlib
+import io
+import os
+import pathlib
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+from unittest import mock
+
+HERE = pathlib.Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent / "src"))
+
+from pywrit import cli  # noqa: E402
+
+FIXTURES = HERE / "fixtures" / "tsjs"
+HAVE_EXTRA = bool(cli._tsjs_parsers())
+_BLOCK_EXTRA = {m: None for m in ("tree_sitter", "tree_sitter_typescript",
+                                  "tree_sitter_javascript",
+                                  "tree_sitter_language_pack")}
+_EXPECT = re.compile(r"//\s*expect:\s*([a-z0-9-]+)")
+_FINDING = re.compile(
+    r"^    (?P<file>\S+):(?P<line>\d+) \[(?P<kind>[a-z]+)\] "
+    r"(?P<rule>[a-z0-9-]+) (?P<func>\S+)\(\): (?P<snippet>.+)$")
+
+
+def _args(path, policy_out, **kw):
+    ns = argparse.Namespace(path=str(path), exclude=[], policy_out=str(policy_out),
+                            apply=False, yes=False, score=False, push_policy=False,
+                            key="")
+    for k, v in kw.items():
+        setattr(ns, k, v)
+    return ns
+
+
+def _run_scan(path, **kw):
+    """Run scan_cmd in-process; return (exit code, stdout)."""
+    with tempfile.TemporaryDirectory() as td:
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            code = cli.scan_cmd(_args(path, pathlib.Path(td) / "policy.json", **kw))
+        return code, buf.getvalue()
+
+
+def _expected():
+    exp = set()
+    for p in sorted(FIXTURES.rglob("*")):
+        if p.suffix not in cli._TSJS_EXTS:
+            continue
+        for i, line in enumerate(p.read_text(encoding="utf-8").splitlines(), 1):
+            m = _EXPECT.search(line)
+            if m:
+                exp.add((str(p.relative_to(FIXTURES)), i, m.group(1)))
+    return exp
+
+
+def _findings(out):
+    return {(m.group("file"), int(m.group("line")), m.group("rule"))
+            for m in map(_FINDING.match, out.splitlines()) if m}
+
+
+def _copy_fixtures(dst):
+    shutil.copytree(str(FIXTURES), str(dst))
+    return dst
+
+
+class FixtureRulesTest(unittest.TestCase):
+    @unittest.skipUnless(HAVE_EXTRA, "polyglot extra not installed")
+    def test_every_expected_finding_and_nothing_else(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = _copy_fixtures(pathlib.Path(td) / "repo")  # outside git
+            code, out = _run_scan(root)
+        self.assertEqual(code, 0)
+        self.assertEqual(_findings(out), _expected(), out)
+
+    def test_every_rule_has_a_fixture(self):
+        covered = {r for (_f, _l, r) in _expected()}
+        self.assertEqual(covered, {r[0] for r in cli._TSJS_RULES})
+
+    @unittest.skipUnless(HAVE_EXTRA, "polyglot extra not installed")
+    def test_negative_reads_not_flagged(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = pathlib.Path(td)
+            shutil.copy(str(FIXTURES / "reads.tsx"), str(root / "reads.tsx"))
+            code, out = _run_scan(root)
+        self.assertEqual(code, 0)
+        self.assertIn("ts/js files scanned: 1  skipped: 0", out)
+        self.assertIn("ts/js write sites: 0 in 0 function(s)", out)
+        self.assertEqual(_findings(out), set())
+        self.assertIn("nothing to instrument.", out)
+
+    @unittest.skipUnless(HAVE_EXTRA, "polyglot extra not installed")
+    def test_output_format_counts_gating_and_verbs(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = _copy_fixtures(pathlib.Path(td) / "repo")
+            policy = pathlib.Path(td) / "p.json"
+            buf = io.StringIO()
+            with contextlib.redirect_stdout(buf):
+                code = cli.scan_cmd(_args(root, policy))
+            out = buf.getvalue()
+            verbs = __import__("json").loads(policy.read_text())
+        self.assertEqual(code, 0)
+        n = len(_expected())
+        self.assertIn("ts/js files scanned: 7  skipped: 0  (scan only, no --apply)", out)
+        self.assertIn("ts/js write sites: %d in 11 function(s)" % n, out)
+        self.assertIn("ts/js gated: 1/%d" % n, out)  # gated.ts calls writCheck
+        self.assertIn("    payments/refunds.service.ts:10 [sdk] stripe-write "
+                      "issueRefund(): stripe.refunds.create({ charge: chargeId })", out)
+        self.assertIn("    http.ts:10 [http] fetch-write createOrder(): fetch(url, "
+                      "{ method: \"POST\", body: JSON.stringify(body) })", out)
+        for v in ("payments.refund", "payments.record", "payments.export",
+                  "storage.save", "storage.create", "http.create", "legacy.write"):
+            self.assertEqual(verbs.get(v), "require_grant", v)
+        self.assertIn("nothing to instrument (ts/js findings are scan-only", out)
+
+    @unittest.skipUnless(HAVE_EXTRA, "polyglot extra not installed")
+    def test_apply_never_rewrites_tsjs_but_still_gates_python(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = pathlib.Path(td) / "repo"
+            (root / "orders").mkdir(parents=True)
+            ts = root / "orders" / "api.ts"
+            ts.write_text('export async function createOrder(u: string) {\n'
+                          '  await fetch(u, { method: "POST" });\n}\n')
+            py = root / "orders" / "store.py"
+            py.write_text('def create_order():\n'
+                          '    with open("/tmp/o", "w") as f:\n'
+                          '        f.write("o")\n')
+            before = ts.read_bytes()
+            code, out = _run_scan(root, apply=True, yes=True)
+            self.assertEqual(code, 0)
+            self.assertEqual(ts.read_bytes(), before)
+            self.assertIn("_writ_check(\"orders.create\")", py.read_text())
+            self.assertIn("orders/api.ts:2 [http] fetch-write createOrder()", out)
+            self.assertIn("applied 1 gate(s) to 1 file(s).", out)
+
+
+class FileWalkTest(unittest.TestCase):
+    """File collection is stdlib-only, so these run with or without the extra."""
+
+    WRITE = 'export function f(){ return fetch("/x", { method: "POST" }); }\n'
+
+    def _tree(self, root, rels):
+        for rel in rels:
+            p = root / rel
+            p.parent.mkdir(parents=True, exist_ok=True)
+            p.write_text(self.WRITE)
+
+    def test_skip_dirs_and_test_files(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = pathlib.Path(td)
+            skipped = ["node_modules/pkg/index.js", "dist/app.js", "build/app.js",
+                       ".next/server/page.js", ".git/hooks/x.js",
+                       "vendor/lib.js", "venv/lib/x.js", ".venv/x.js",
+                       "src/__tests__/a.ts", "tests/a.ts", "src/a.test.ts",
+                       "src/a.spec.tsx", "types/a.d.ts", "public/app.min.js",
+                       "src/readme.md", "src/a.py"]
+            kept = ["src/a.ts", "src/b.tsx", "src/c.js", "src/d.jsx",
+                    "src/e.mjs", "src/f.cjs", "lib/distance.ts"]
+            self._tree(root, skipped + kept)
+            got = [str(p.relative_to(root))
+                   for p in cli._tsjs_collect_files(root, [])]
+        self.assertEqual(sorted(got), sorted(kept))
+
+    def test_exclude_substring(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = pathlib.Path(td)
+            self._tree(root, ["src/a.ts", "generated/b.ts"])
+            got = [str(p.relative_to(root))
+                   for p in cli._tsjs_collect_files(root, ["generated"])]
+        self.assertEqual(got, ["src/a.ts"])
+
+    @unittest.skipUnless(shutil.which("git"), "git not installed")
+    def test_respects_gitignore_inside_git_repo(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = pathlib.Path(td)
+            subprocess.run(["git", "init", "-q", str(root)], check=True)
+            (root / ".gitignore").write_text("generated/\n*.gen.ts\n")
+            self._tree(root, ["src/a.ts", "generated/b.ts", "src/c.gen.ts",
+                              "node_modules/x/y.js"])
+            got = [str(p.relative_to(root))
+                   for p in cli._tsjs_collect_files(root, [])]
+        self.assertEqual(got, ["src/a.ts"])
+
+
+class MissingExtraTest(unittest.TestCase):
+    def test_hint_once_and_python_still_scanned(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = pathlib.Path(td)
+            (root / "web").mkdir()
+            (root / "web" / "a.ts").write_text(FileWalkTest.WRITE)
+            (root / "web" / "b.js").write_text(FileWalkTest.WRITE)
+            (root / "orders.py").write_text(
+                'def create_order(db):\n    db.execute("INSERT INTO o VALUES (1)")\n')
+            with mock.patch.dict(sys.modules, _BLOCK_EXTRA):
+                self.assertEqual(cli._tsjs_parsers(), {})
+                code, out = _run_scan(root)
+        self.assertEqual(code, 0)
+        hints = [l for l in out.splitlines() if "hint:" in l]
+        self.assertEqual(hints, ["  hint: 2 TS/JS file(s) not scanned; install "
+                                 "the extra: pip install 'pywrit[polyglot]'"])
+        self.assertIn("write sites: 1 in 1 function(s)", out)
+        self.assertIn("orders.create", out)
+        self.assertNotIn("ts/js files scanned", out)
+
+    def test_python_only_repo_output_unchanged(self):
+        with tempfile.TemporaryDirectory() as td:
+            root = pathlib.Path(td)
+            (root / "orders.py").write_text(
+                'def create_order(db):\n    db.execute("INSERT INTO o VALUES (1)")\n')
+            with mock.patch.dict(sys.modules, _BLOCK_EXTRA):
+                code, out = _run_scan(root)
+        self.assertEqual(code, 0)
+        self.assertNotIn("hint:", out)
+        self.assertNotIn("ts/js", out)
+        self.assertTrue(out.startswith("writ scan: %s\n  files scanned: 1  skipped: 0\n"
+                                       "  write sites: 1 in 1 function(s)\n"
+                                       "  gated: 0/1 (0%%)\n  verbs discovered: 1\n"
+                                       "    orders.create\n" % root.resolve()), out)
+
+
+class CliSyncTest(unittest.TestCase):
+    def test_download_copy_is_byte_identical(self):
+        web = HERE.parent.parent / "gate" / "web" / "writ"
+        if not web.exists():
+            self.skipTest("gate/web/writ not present")
+        self.assertEqual(web.read_bytes(),
+                         (HERE.parent / "src" / "pywrit" / "cli.py").read_bytes())
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

pywrit-0.2.4/src/pywrit.egg-info/requires.txt

@@ -1 +0,0 @@
-httpx>=0.27