vibecodedshit 0.0.0-stage → 0.2.0

package/python/graph_helper.py

@@ -0,0 +1,277 @@
+"""Import graph and contract violations for one unit, through grimp and import-linter.
+
+Run with the interpreter that holds import-linter (see src/measure/d3/py/interpreter.ts), in isolated mode:
+    python -I graph_helper.py --in in.json --out out.json
+
+Input:  {"workDir", "roots": [{"dir", "name"}], "declared": "<abs path>" | null, "contracts": [options]}
+Output: {"versions", "emptied", "edges", "violations", "skipped"} or {"error": "<message>"}
+
+Repository code is never executed: grimp and import-linter read source files, and each root package is
+looked up with importlib.util.find_spec (top-level names only, no package __init__ runs).
+"""
+import argparse
+import ast
+import copy
+import importlib.metadata
+import importlib.util
+import json
+import os
+import sys
+
+DIRECTION_TYPES = ("layers", "forbidden", "independence")
+
+
+def fail(message):
+    return {"error": message}
+
+
+def load_import_linter():
+    try:
+        import grimp
+        from importlinter import configuration
+        from importlinter.application import use_cases
+    except ImportError as exc:
+        return None, fail("import-linter cannot be imported: %s" % exc)
+    version = importlib.metadata.version("import-linter")
+    for name in ("read_user_options", "create_report", "_register_contract_types"):
+        if not hasattr(use_cases, name):
+            return None, fail("unsupported import-linter %s: missing %s" % (version, name))
+    for name in ("build_graph",):
+        if not hasattr(grimp, name):
+            return None, fail("unsupported grimp: missing %s" % name)
+    configuration.configure()
+    return (grimp, use_cases, configuration, version), None
+
+
+def empty_unparseable(work_dir, roots):
+    emptied = []
+    for root in roots:
+        base = os.path.join(work_dir, root["dir"], root["name"])
+        for current, _dirs, files in os.walk(base):
+            for name in files:
+                if not name.endswith(".py"):
+                    continue
+                path = os.path.join(current, name)
+                try:
+                    with open(path, "rb") as handle:
+                        ast.parse(handle.read())
+                except (SyntaxError, ValueError, RecursionError, MemoryError):
+                    with open(path, "wb"):
+                        pass
+                    emptied.append(os.path.relpath(path, work_dir).replace(os.sep, "/"))
+    return sorted(emptied)
+
+
+class FileMap:
+    """Module name to repository-relative file, for the modules that have one."""
+
+    def __init__(self, work_dir, roots):
+        self.work_dir = work_dir
+        self.roots = roots
+        self.cache = {}
+
+    def file_of(self, module):
+        if module in self.cache:
+            return self.cache[module]
+        found = None
+        top = module.split(".")[0]
+        parts = module.split(".")
+        for root in self.roots:
+            if root["name"] != top:
+                continue
+            base = os.path.join(self.work_dir, root["dir"], *parts)
+            for candidate in (base + ".py", os.path.join(base, "__init__.py")):
+                if os.path.isfile(candidate):
+                    found = os.path.relpath(candidate, self.work_dir).replace(os.sep, "/")
+                    break
+            if found:
+                break
+        self.cache[module] = found
+        return found
+
+
+def emit_edges(graph, files):
+    edges = []
+    for module in sorted(graph.modules):
+        source = files.file_of(module)
+        if source is None:
+            continue
+        for imported in sorted(graph.find_modules_directly_imported_by(module)):
+            target = files.file_of(imported)
+            if target is None or target == source:
+                continue
+            lines = sorted(
+                {d["line_number"] for d in graph.get_import_details(importer=module, imported=imported)}
+            )
+            edges.append({"from": source, "to": target, "lines": lines})
+    return edges
+
+
+def one_step_chains(raw_chains):
+    for item in raw_chains:
+        chain = item["chain"] if isinstance(item, dict) else item
+        if len(chain) == 1:
+            yield chain[0]
+
+
+def violations_of(contract_type, metadata):
+    if contract_type == "layers":
+        for dependency in metadata.get("invalid_dependencies", []):
+            for step in one_step_chains(dependency["routes"]):
+                yield step
+    elif contract_type == "independence":
+        for entry in metadata.get("invalid_chains", []):
+            for step in one_step_chains(entry["chains"]):
+                yield step
+    else:
+        for entry in metadata.get("invalid_chains", []):
+            for step in one_step_chains(entry["chains"]):
+                yield step
+
+
+def contract_type_of(contract):
+    name = type(contract).__name__.lower()
+    if "layer" in name:
+        return "layers"
+    if "independ" in name:
+        return "independence"
+    return "forbidden"
+
+
+def run_report(use_cases, session, contracts):
+    from importlinter.application.user_options import UserOptions
+
+    options = UserOptions(session_options=session, contracts_options=contracts)
+    use_cases._register_contract_types(options)
+    report = use_cases.create_report(options, cache_dir=None)
+    if report.could_not_run:
+        reasons = "; ".join(
+            "%s: %s" % (name, exc) for name, exc in report.invalid_contract_options.items()
+        )
+        raise ValueError(reasons)
+    return report
+
+
+def collect(report, files, out):
+    for contract, check in report.get_contracts_and_checks():
+        for step in violations_of(contract_type_of(contract), check.metadata):
+            imported_file = files.file_of(step["imported"])
+            importer_file = files.file_of(step["importer"])
+            if importer_file is None:
+                continue
+            out.append(
+                {
+                    "contract": contract.name,
+                    "importer": importer_file,
+                    "imported": imported_file or step["imported"],
+                    "external": imported_file is None,
+                }
+            )
+
+
+def run_contracts(use_cases, session, contracts, files, violations, skipped):
+    if not contracts:
+        return
+    try:
+        collect(run_report(use_cases, session, contracts), files, violations)
+        return
+    except Exception:  # noqa: BLE001 - one bad contract aborts the whole report; retry one by one
+        pass
+    for options in contracts:
+        try:
+            collect(run_report(use_cases, copy.deepcopy(session), [options]), files, violations)
+        except Exception as exc:  # noqa: BLE001
+            skipped.append({"contract": options.get("name", "*"), "reason": "%s: %s" % (type(exc).__name__, exc)})
+
+
+def declared_contracts(use_cases, declared, root_names, skipped):
+    try:
+        options = use_cases.read_user_options(declared)
+    except Exception as exc:  # noqa: BLE001
+        skipped.append({"contract": "*", "reason": "%s: %s" % (type(exc).__name__, exc)})
+        return None, []
+    session = dict(options.session_options)
+    session.pop("contract_types", None)
+    names = [name for name in session.get("root_packages", []) if name in root_names]
+    if not names:
+        skipped.append({"contract": "*", "reason": "the declared rules name no first-party package of this unit"})
+        return None, []
+    session["root_packages"] = names
+    # import-linter reads boolean session options as strings
+    session["include_external_packages"] = "true"
+    session["exclude_type_checking_imports"] = "false"
+    contracts = [c for c in options.contracts_options if c.get("type") in DIRECTION_TYPES]
+    return session, contracts
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--in", dest="infile", required=True)
+    parser.add_argument("--out", dest="outfile", required=True)
+    args = parser.parse_args()
+    with open(args.infile, encoding="utf8") as handle:
+        request = json.load(handle)
+
+    def write(result):
+        with open(args.outfile, "w", encoding="utf8") as handle:
+            json.dump(result, handle)
+
+    loaded, error = load_import_linter()
+    if error:
+        write(error)
+        return
+    grimp, use_cases, _configuration, il_version = loaded
+
+    work_dir = os.path.abspath(request["workDir"])
+    roots = request["roots"]
+    for root in reversed(roots):
+        sys.path.insert(0, os.path.join(work_dir, root["dir"]))
+    skipped = []
+    emptied = empty_unparseable(work_dir, roots)
+
+    # A root whose spec is not inside the work copy is a first-party package named like an imported module.
+    usable = []
+    for root in roots:
+        spec = importlib.util.find_spec(root["name"])
+        location = spec.origin if spec and spec.origin else None
+        locations = list(spec.submodule_search_locations or []) if spec else []
+        inside = [p for p in ([location] if location else []) + locations if os.path.abspath(p).startswith(work_dir + os.sep)]
+        if spec is None or not inside:
+            skipped.append({"contract": "*", "reason": "root package %s is shadowed outside the work copy" % root["name"]})
+            continue
+        usable.append(root)
+    names = [root["name"] for root in usable]
+    result = {
+        "versions": {"grimp": importlib.metadata.version("grimp"), "import-linter": il_version},
+        "emptied": emptied,
+        "edges": [],
+        "violations": [],
+        "skipped": skipped,
+    }
+    if not usable:
+        write(result)
+        return
+
+    files = FileMap(work_dir, usable)
+    graph = grimp.build_graph(*names, include_external_packages=True, cache_dir=None)
+    result["edges"] = emit_edges(graph, files)
+
+    session = {"root_packages": names, "include_external_packages": "true", "exclude_type_checking_imports": "false"}
+    run_contracts(use_cases, session, request.get("contracts", []), files, result["violations"], skipped)
+    if request.get("declared"):
+        declared_session, declared = declared_contracts(use_cases, request["declared"], set(names), skipped)
+        if declared_session is not None:
+            run_contracts(use_cases, declared_session, declared, files, result["violations"], skipped)
+    write(result)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as exc:  # noqa: BLE001
+        try:
+            outfile = sys.argv[sys.argv.index("--out") + 1]
+            with open(outfile, "w", encoding="utf8") as handle:
+                json.dump(fail("%s: %s" % (type(exc).__name__, exc)), handle)
+        except (ValueError, IndexError, OSError):
+            raise exc

package/python/imports_helper.py

@@ -0,0 +1,132 @@
+"""Import statements, their flags and builtin open() calls per file. Stdlib only.
+
+Input (stdin): {"root": "<abs>", "files": ["<rel>", ...]}
+Output (stdout): {"files": {"<rel>": {"syntaxError": bool, "imports": [...], "opensBuiltin": bool}}}
+"""
+import ast
+import json
+import os
+import sys
+
+
+def is_type_checking(test):
+    if isinstance(test, ast.Name):
+        return test.id == "TYPE_CHECKING"
+    if isinstance(test, ast.Attribute):
+        return test.attr == "TYPE_CHECKING"
+    return False
+
+
+def bound_names(tree):
+    """Every name the file binds anywhere, for the 'defines its own open' rule."""
+    names = set()
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            names.add(node.name)
+        elif isinstance(node, ast.Name) and isinstance(node.ctx, (ast.Store, ast.Del)):
+            names.add(node.id)
+        elif isinstance(node, ast.arg):
+            names.add(node.arg)
+        elif isinstance(node, (ast.Import, ast.ImportFrom)):
+            for alias in node.names:
+                names.add(alias.asname or alias.name.split(".")[0])
+        elif isinstance(node, ast.ExceptHandler) and node.name:
+            names.add(node.name)
+        elif isinstance(node, (ast.Global, ast.Nonlocal)):
+            names.update(node.names)
+        elif isinstance(node, (ast.MatchAs, ast.MatchStar)) and node.name:
+            names.add(node.name)
+        elif isinstance(node, ast.MatchMapping) and node.rest:
+            names.add(node.rest)
+    return names
+
+
+def analyze(source):
+    tree = ast.parse(source)
+    imports = []
+
+    def visit(node, lazy, type_only):
+        if isinstance(node, ast.Import):
+            imports.append(
+                {
+                    "line": node.lineno,
+                    "level": 0,
+                    "modules": [alias.name for alias in node.names],
+                    "lazy": lazy,
+                    "typeOnly": type_only,
+                }
+            )
+            return
+        if isinstance(node, ast.ImportFrom):
+            imports.append(
+                {
+                    "line": node.lineno,
+                    "level": node.level,
+                    "modules": [node.module or ""],
+                    "lazy": lazy,
+                    "typeOnly": type_only,
+                }
+            )
+            return
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            for child in node.body:
+                visit(child, True, type_only)
+            # decorators, defaults and annotations run at definition time
+            for child in ast.iter_child_nodes(node):
+                if child not in node.body:
+                    visit(child, lazy, type_only)
+            return
+        if isinstance(node, ast.Lambda):
+            visit(node.body, True, type_only)
+            for child in ast.iter_child_nodes(node):
+                if child is not node.body:
+                    visit(child, lazy, type_only)
+            return
+        if isinstance(node, ast.If) and is_type_checking(node.test):
+            visit(node.test, lazy, type_only)
+            for child in node.body:
+                visit(child, lazy, True)
+            for child in node.orelse:
+                visit(child, lazy, type_only)
+            return
+        for child in ast.iter_child_nodes(node):
+            visit(child, lazy, type_only)
+
+    visit(tree, False, False)
+
+    opens = False
+    shadowed = "open" in bound_names(tree)
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Call):
+            continue
+        func = node.func
+        if isinstance(func, ast.Name) and func.id == "open" and not shadowed:
+            opens = True
+        elif (
+            isinstance(func, ast.Attribute)
+            and func.attr == "open"
+            and isinstance(func.value, ast.Name)
+            and func.value.id == "builtins"
+        ):
+            opens = True
+    return {"syntaxError": False, "imports": imports, "opensBuiltin": opens}
+
+
+def main():
+    request = json.load(sys.stdin)
+    root = request["root"]
+    result = {}
+    for rel in request["files"]:
+        try:
+            with open(os.path.join(root, rel), "rb") as handle:
+                source = handle.read()
+            result[rel] = analyze(source)
+        except (SyntaxError, ValueError, RecursionError, MemoryError):
+            result[rel] = {"syntaxError": True, "imports": [], "opensBuiltin": False}
+        except OSError:
+            result[rel] = {"syntaxError": True, "imports": [], "opensBuiltin": False}
+    json.dump({"files": result}, sys.stdout)
+
+
+if __name__ == "__main__":
+    main()

package/python/nox_helper.py

@@ -0,0 +1,79 @@
+"""Sessions of noxfile.py files. Standard library only.
+
+Reads {"files": [relative paths]} as JSON on stdin and prints
+{path: {"ok": false} | {"ok": true, "sessions": [{"name", "commands": [str], "notify": [str]}]}}.
+
+A session is a function decorated with nox.session (with or without arguments). Its name is the name=
+keyword when that is a string literal, else the function name. Commands are session.run(...) and
+session.run_always(...) calls with the positional arguments joined by spaces (a non-literal argument
+becomes "?"; keyword arguments are ignored). session.notify("<name>") is a call to another session.
+"""
+
+import ast
+import json
+import sys
+
+
+def literal(node):
+    if isinstance(node, ast.Constant) and isinstance(node.value, str):
+        return node.value
+    return None
+
+
+def session_decorator(node):
+    target = node.func if isinstance(node, ast.Call) else node
+    if isinstance(target, ast.Attribute):
+        return target.attr == "session" and isinstance(target.value, ast.Name) and target.value.id == "nox"
+    return isinstance(target, ast.Name) and target.id == "session"
+
+
+def session_name(func, decorator):
+    if isinstance(decorator, ast.Call):
+        for keyword in decorator.keywords:
+            if keyword.arg == "name":
+                name = literal(keyword.value)
+                if name is not None:
+                    return name
+    return func.name
+
+
+def analyze(path):
+    with open(path, "rb") as handle:
+        tree = ast.parse(handle.read().decode("utf-8", errors="replace"), filename=path)
+    sessions = []
+    for func in ast.walk(tree):
+        if not isinstance(func, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        decorators = [d for d in func.decorator_list if session_decorator(d)]
+        if not decorators:
+            continue
+        arg = func.args.args[0].arg if func.args.args else "session"
+        commands = []
+        notify = []
+        for node in ast.walk(func):
+            if not (isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute)):
+                continue
+            if not (isinstance(node.func.value, ast.Name) and node.func.value.id == arg):
+                continue
+            if node.func.attr in ("run", "run_always"):
+                parts = [literal(a) if literal(a) is not None else "?" for a in node.args if not isinstance(a, ast.Starred)]
+                if parts:
+                    commands.append(" ".join(parts))
+            elif node.func.attr == "notify" and node.args and literal(node.args[0]) is not None:
+                notify.append(literal(node.args[0]))
+        sessions.append({"name": session_name(func, decorators[0]), "commands": commands, "notify": notify})
+    return sessions
+
+
+def main():
+    request = json.load(sys.stdin)
+    out = {}
+    for path in request["files"]:
+        try:
+            out[path] = {"ok": True, "sessions": analyze(path)}
+        except (SyntaxError, ValueError, OSError):
+            out[path] = {"ok": False}
+    json.dump(out, sys.stdout)
+
+
+main()

package/python/scope_helper.py

@@ -0,0 +1,96 @@
+"""Line classification for Python files. Standard library only.
+
+Reads {"files": [relative paths]} as JSON on stdin and prints
+{path: {"parsed": bool, "hasDef": bool, "lines": int}} as JSON on stdout.
+"lines" is the number of non-blank lines that are not comment-only and not
+docstring lines.
+"""
+
+import ast
+import io
+import json
+import sys
+import tokenize
+
+NON_CODE = {
+    tokenize.COMMENT,
+    tokenize.NL,
+    tokenize.NEWLINE,
+    tokenize.INDENT,
+    tokenize.DEDENT,
+    tokenize.ENDMARKER,
+}
+
+
+def read_text(path):
+    with open(path, "rb") as handle:
+        raw = handle.read()
+    try:
+        encoding, _ = tokenize.detect_encoding(io.BytesIO(raw).readline)
+        text = raw.decode(encoding)
+    except (SyntaxError, UnicodeDecodeError, LookupError):
+        text = raw.decode("utf-8", errors="replace")
+    return text.replace("\r\n", "\n").replace("\r", "\n")
+
+
+def fallback(text):
+    count = 0
+    for line in text.split("\n"):
+        stripped = line.strip()
+        if stripped and not stripped.startswith("#"):
+            count += 1
+    return {"parsed": False, "hasDef": True, "lines": count}
+
+
+def docstring_lines(tree):
+    lines = set()
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.Module, ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef)):
+            body = node.body
+            if body:
+                first = body[0]
+                if (
+                    isinstance(first, ast.Expr)
+                    and isinstance(first.value, ast.Constant)
+                    and isinstance(first.value.value, str)
+                ):
+                    lines.update(range(first.lineno, first.end_lineno + 1))
+    return lines
+
+
+def analyze(path):
+    text = read_text(path)
+    try:
+        tree = ast.parse(text)
+        code = set()
+        for tok in tokenize.generate_tokens(io.StringIO(text).readline):
+            if tok.type not in NON_CODE:
+                code.update(range(tok.start[0], tok.end[0] + 1))
+    except (SyntaxError, ValueError, tokenize.TokenError, RecursionError):
+        return fallback(text)
+
+    doc = docstring_lines(tree)
+    all_lines = text.split("\n")
+    count = 0
+    for number in code:
+        if number in doc:
+            continue
+        if number - 1 < len(all_lines) and all_lines[number - 1].strip() != "":
+            count += 1
+    has_def = any(
+        isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef))
+        for node in ast.walk(tree)
+    )
+    return {"parsed": True, "hasDef": has_def, "lines": count}
+
+
+def main():
+    request = json.load(sys.stdin)
+    result = {}
+    for path in request["files"]:
+        result[path] = analyze(path)
+    json.dump(result, sys.stdout)
+
+
+if __name__ == "__main__":
+    main()