stackthread 0.1.0.dev2__py3-none-any.whl

stackthread/lang/js/aliases.py

@@ -0,0 +1,133 @@
+"""Import aliases of a frontend source: from config, tsconfig/jsconfig `paths`, and literal Vite `resolve.alias`."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Any
+
+
+def loads_jsonc(text: str) -> Any:
+    """JSON with comments and trailing commas, as tsconfig files allow."""
+    out, i, n = [], 0, len(text)
+    while i < n:
+        c = text[i]
+        if c == '"':
+            j = i + 1
+            while j < n and text[j] != '"':
+                j += 2 if text[j] == "\\" else 1
+            out.append(text[i : j + 1])
+            i = j + 1
+        elif text.startswith("//", i):
+            j = text.find("\n", i)
+            i = n if j == -1 else j
+        elif text.startswith("/*", i):
+            j = text.find("*/", i + 2)
+            i = n if j == -1 else j + 2
+        else:
+            out.append(c)
+            i += 1
+    cleaned = re.sub(r",(\s*[}\]])", r"\1", "".join(out))
+    return json.loads(cleaned)
+
+
+def _tsconfig_paths(file: Path, depth: int = 0) -> tuple[dict[str, str], str | None]:
+    """`compilerOptions.paths` as {alias prefix: folder relative to the source root}, and baseUrl."""
+    try:
+        data = loads_jsonc(file.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return {}, None
+    out: dict[str, str] = {}
+    base_url: str | None = None
+    extends = data.get("extends")
+    if isinstance(extends, str) and extends.startswith(".") and depth < 3:
+        parent = file.parent / extends
+        if parent.suffix != ".json":
+            parent = parent.with_suffix(".json")
+        out, base_url = _tsconfig_paths(parent, depth + 1)
+    for ref in data.get("references", []) or []:
+        ref_path = ref.get("path") if isinstance(ref, dict) else None
+        if isinstance(ref_path, str) and depth < 3:
+            target = file.parent / ref_path
+            if target.is_dir():
+                target = target / "tsconfig.json"
+            more, more_base = _tsconfig_paths(target, depth + 1)
+            out.update(more)
+            base_url = base_url or more_base
+    options = data.get("compilerOptions", {}) or {}
+    base = options.get("baseUrl")
+    if isinstance(base, str):
+        base_url = str((file.parent / base).resolve())
+    root = Path(base_url) if base_url else file.parent
+    for key, targets in (options.get("paths") or {}).items():
+        if not targets or not isinstance(targets, list):
+            continue
+        prefix = key.removesuffix("/*").removesuffix("*")
+        folder = str(targets[0]).removesuffix("/*").removesuffix("*")
+        out[prefix] = str((root / folder).resolve())
+    return out, base_url
+
+
+_VITE_ALIAS = re.compile(
+    r"""['"]?(?P<key>[@~#$\w/.-]+)['"]?\s*:\s*(?:path\.)?(?:resolve|join)\(\s*__dirname\s*,\s*['"](?P<dir>[^'"]+)['"]\s*\)"""
+    r"""|['"]?(?P<key2>[@~#$\w/.-]+)['"]?\s*:\s*fileURLToPath\(\s*new URL\(\s*['"](?P<dir2>[^'"]+)['"]"""
+    r"""|find:\s*['"](?P<key3>[^'"]+)['"]\s*,\s*replacement:\s*(?:path\.resolve\(\s*__dirname\s*,\s*)?['"](?P<dir3>[^'"]+)['"]"""
+)
+
+
+def _vite_aliases(root: Path) -> dict[str, str]:
+    for name in ("vite.config.ts", "vite.config.mts", "vite.config.js", "vite.config.mjs"):
+        file = root / name
+        if not file.is_file():
+            continue
+        text = file.read_text(encoding="utf-8", errors="replace")
+        out = {}
+        for m in _VITE_ALIAS.finditer(text):
+            key = m.group("key") or m.group("key2") or m.group("key3")
+            folder = m.group("dir") or m.group("dir2") or m.group("dir3")
+            if key and folder:
+                out[key.rstrip("/")] = str((root / folder).resolve())
+        return out
+    return {}
+
+
+def detect(source_root: Path, configured: dict[str, str]) -> tuple[dict[str, Path], Path | None]:
+    """Aliases as {prefix: absolute folder}, most specific first, and the baseUrl folder if any."""
+    aliases: dict[str, str] = {}
+    base_url: str | None = None
+    for name in ("tsconfig.json", "jsconfig.json"):
+        file = source_root / name
+        if file.is_file():
+            found, base_url = _tsconfig_paths(file)
+            aliases.update(found)
+            break
+    aliases.update(_vite_aliases(source_root))
+    for key, folder in configured.items():
+        aliases[key.rstrip("/").removesuffix("/*")] = str((source_root / folder).resolve())
+    ordered = sorted(aliases.items(), key=lambda kv: -len(kv[0]))
+    return {k: Path(v) for k, v in ordered}, Path(base_url) if base_url else None
+
+
+def proxy_prefixes(source_root: Path) -> list[tuple[str, str]]:
+    """Vite `server.proxy` keys and literal rewrites: [(client prefix, server prefix)]."""
+    for name in ("vite.config.ts", "vite.config.mts", "vite.config.js", "vite.config.mjs"):
+        file = source_root / name
+        if not file.is_file():
+            continue
+        text = file.read_text(encoding="utf-8", errors="replace")
+        block = re.search(r"proxy\s*:\s*\{", text)
+        if not block:
+            return []
+        out = []
+        for m in re.finditer(
+            r"""['"](/[^'"]*)['"]\s*:\s*(\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}|['"][^'"]+['"])""", text[block.end() :]
+        ):
+            prefix, body = m.group(1), m.group(2)
+            rewrite = re.search(r"replace\(\s*/\^?\\?(/[^/]*?)/\s*,\s*['\"]([^'\"]*)['\"]", body)
+            if rewrite:
+                out.append((rewrite.group(1).replace("\\/", "/"), rewrite.group(2)))
+            else:
+                out.append((prefix, prefix))
+        return out
+    return []

stackthread/lang/js/build.py

@@ -0,0 +1,455 @@
+"""JavaScript/TypeScript facts -> graph: files, functions and components, imports, renders, calls, pages, requests.
+
+Resolution follows imports (relative paths, aliases, baseUrl, index files, re-exports, `export *`), module-level
+object literals (`api.getItems`), and objects returned by project functions (`calls = visitCalls(); calls.save()`).
+"""
+
+from __future__ import annotations
+
+import posixpath
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, cast
+
+from stackthread.config import SourceConfig
+from stackthread.lang.js import aliases as alias_mod
+from stackthread.model import Edge, Finding, Graph, Node, NodeKind, Site
+
+EXTS = (".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts")
+
+
+def file_id(source: str, file: str) -> str:
+    return f"js:{source}:{file}"
+
+
+def fn_id(source: str, file: str, fn: str) -> str:
+    return f"js:{source}:{file}#{fn}"
+
+
+@dataclass
+class Request:
+    """One HTTP call site, ready for linking."""
+
+    node: str  # function or file node making the call
+    method: str
+    url: str
+    file: str
+    line: int
+    confidence: str
+    client: str
+    raw: str = ""
+    source: str = ""
+
+
+@dataclass
+class JsBuild:
+    graph: Graph
+    source: SourceConfig
+    project_root: Path
+    facts: dict[str, dict[str, Any]]  # file -> facts
+    aliases: dict[str, str] = field(default_factory=dict)  # prefix -> project-relative folder ('' = root)
+    base_url: str | None = None
+    module_cache: dict[tuple[str, str], str | None] = field(default_factory=dict)
+    requests: list[Request] = field(default_factory=list)
+    fn_index: dict[str, dict[str, dict[str, Any]]] = field(default_factory=dict)  # file -> fn id -> fact
+    elements: dict[str, dict[str, Any]] = field(default_factory=dict)  # "file:line:col" -> element fact
+    exports_cache: dict[tuple[str, str], str | None] = field(default_factory=dict)
+
+    # ---- module resolution ----
+
+    def _rel_folder(self, path: Path) -> str | None:
+        try:
+            rel = path.resolve().relative_to(self.project_root.resolve()).as_posix()
+        except ValueError:
+            return None
+        return "" if rel == "." else rel
+
+    def _candidates(self, base: str) -> list[str]:
+        out = [base] if base.endswith(EXTS) else []
+        if base.endswith((".js", ".jsx", ".mjs", ".cjs")):
+            stem = base.rsplit(".", 1)[0]
+            out += [stem + ext for ext in (".ts", ".tsx", ".mts", ".cts")]
+        out += [base + ext for ext in EXTS] + [f"{base}/index{ext}" for ext in EXTS]
+        return out
+
+    def resolve_module(self, spec: str, from_file: str) -> str | None:
+        """A project-relative file for an import specifier, or None for packages and misses."""
+        key = (spec, posixpath.dirname(from_file) if spec.startswith(".") else "")
+        if key in self.module_cache:
+            return self.module_cache[key]
+        bases: list[str] = []
+        if spec.startswith("."):
+            bases.append(posixpath.normpath(posixpath.join(posixpath.dirname(from_file), spec)))
+        else:
+            for prefix, folder in self.aliases.items():
+                if (
+                    spec == prefix
+                    or spec.startswith(prefix + "/")
+                    or (prefix.endswith("/") and spec.startswith(prefix))
+                ):
+                    rest = spec[len(prefix) :].lstrip("/")
+                    bases.append(posixpath.normpath(posixpath.join(folder, rest)) if rest else folder)
+                    break
+            if not bases and self.base_url is not None:
+                bases.append(posixpath.normpath(posixpath.join(self.base_url, spec)))
+        result = None
+        for base in bases:
+            result = next((c for c in self._candidates(base) if c in self.facts), None)
+            if result:
+                break
+        self.module_cache[key] = result
+        return result
+
+    # ---- symbols ----
+
+    def local_fn(self, file: str, name: str) -> str | None:
+        fns = self.fn_index.get(file, {})
+        return fn_id(self.source.name, file, name) if name in fns else None
+
+    def resolve_export(self, file: str, name: str, seen: frozenset[tuple[str, str]] = frozenset()) -> str | None:
+        """The node a file exports under `name`: a function/component node, or an object prefix `file#obj`."""
+        key = (file, name)
+        if key in self.exports_cache:
+            return self.exports_cache[key]
+        if key in seen:
+            return None
+        seen = seen | {key}
+        facts = self.facts.get(file)
+        result: str | None = None
+        if facts is not None:
+            for exp in facts["exports"]:
+                if exp["name"] != name:
+                    continue
+                if exp.get("source"):
+                    target = self.resolve_module(exp["source"], file)
+                    local = exp.get("local") or name
+                    if target and local == "*":
+                        result = file_id(self.source.name, target)
+                    elif target:
+                        result = self.resolve_export(target, local, seen)
+                else:
+                    local = exp.get("local") or name
+                    result = (
+                        self.local_fn(file, local)
+                        or self._object_prefix(file, local)
+                        or self._via_import(file, local, seen)
+                    )
+                if result:
+                    break
+            if result is None and name != "default":
+                for exp in facts["exports"]:
+                    if exp["name"] == "*" and exp.get("source"):
+                        target = self.resolve_module(exp["source"], file)
+                        if target and (result := self.resolve_export(target, name, seen)):
+                            break
+        self.exports_cache[key] = result
+        return result
+
+    def _object_prefix(self, file: str, name: str) -> str | None:
+        """`export const api = { get() {} }`: the object as a prefix for its methods."""
+        if any(fid.startswith(name + ".") for fid in self.fn_index.get(file, {})):
+            return fn_id(self.source.name, file, name)
+        return None
+
+    def _via_import(self, file: str, local: str, seen: frozenset[tuple[str, str]]) -> str | None:
+        for imp in self.facts[file]["imports"]:
+            if imp["local"] == local and not imp["typeOnly"]:
+                target = self.resolve_module(imp["source"], file)
+                if target is None:
+                    return None
+                if imp["imported"] == "*":
+                    return file_id(self.source.name, target)
+                return self.resolve_export(target, imp["imported"], seen)
+        return None
+
+    def resolve_name(self, file: str, name: str) -> str | None:
+        """A top-level name in a file: local function, object, or import."""
+        return self.local_fn(file, name) or self._object_prefix(file, name) or self._via_import(file, name, frozenset())
+
+    def member(self, target: str | None, prop: str) -> str | None:
+        """`target.prop` where target is a file node (namespace import) or an object/function prefix."""
+        if target is None:
+            return None
+        if target.startswith("js:") and "#" not in target:
+            file = target.split(":", 2)[2]
+            return self.resolve_export(file, prop)
+        file, _, obj = target.split(":", 2)[2].partition("#")
+        candidate = f"{obj}.{prop}"
+        return fn_id(self.source.name, file, candidate) if candidate in self.fn_index.get(file, {}) else None
+
+    def resolve_callee(self, file: str, fn: dict[str, Any] | None, callee: str) -> tuple[str | None, str]:
+        """Resolve a call made inside `fn` (None for module level). Returns (node id, confidence)."""
+        parts = callee.replace("?.", ".").split(".")
+        if any("(" in p or "[" in p for p in parts):
+            return None, "exact"
+        head = parts[0]
+        bindings = fn.get("bindings", {}) if fn else {}
+        if head in bindings:
+            binding = bindings[head]
+            if len(parts) == 1:
+                return None, "exact"  # a local function or value: shown through the binding, not a node
+            # `calls = visitCalls(...)`, then `calls.save(...)`: a member of what a project function returned
+            for inner in binding.get("calls", []) + ([binding["init"]] if binding.get("init") else []):
+                target, _ = self.resolve_callee(file, None, inner)
+                if target:
+                    found = self.member(target, parts[1])
+                    if found:
+                        return found, "inferred"
+            return None, "exact"
+        if head in (
+            "this",
+            "super",
+            "window",
+            "document",
+            "console",
+            "JSON",
+            "Math",
+            "Object",
+            "Array",
+            "Promise",
+            "React",
+        ):
+            if head == "this" and fn and "." in fn["id"] and len(parts) == 2:
+                owner = fn["id"].rsplit(".", 1)[0]
+                return self.local_fn(file, f"{owner}.{parts[1]}"), "exact"
+            return None, "exact"
+        target = self.resolve_name(file, head)
+        for prop in parts[1:]:
+            target = self.member(target, prop)
+        if (
+            target
+            and "#" in target
+            and target.split("#", 1)[1] in self.fn_index.get(target.split(":", 2)[2].split("#")[0], {})
+        ):
+            return target, "exact"
+        return None, "exact"
+
+    def component_for(self, file: str, tag: str) -> str | None:
+        parts = tag.split(".")
+        target = self.resolve_name(file, parts[0])
+        for prop in parts[1:]:
+            target = self.member(target, prop)
+        if target and "#" in target:
+            f, _, fid = target.split(":", 2)[2].partition("#")
+            if fid in self.fn_index.get(f, {}):
+                return target
+        return None
+
+    # ---- graph ----
+
+    def run(self) -> None:
+        src, g = self.source.name, self.graph
+        found, base_url = alias_mod.detect(self.project_root / self.source.root, self.source.alias)
+        self.aliases = {k: rel for k, v in found.items() if (rel := self._rel_folder(v)) is not None}
+        self.base_url = self._rel_folder(base_url) if base_url else None
+        for file, facts in self.facts.items():
+            self.fn_index[file] = {f["id"]: f for f in facts["functions"]}
+            for el in facts["elements"]:
+                self.elements[f"{file}:{el['line']}:{el['col']}"] = dict(el, file=file)
+        for file, facts in self.facts.items():
+            g.add_node(
+                Node(
+                    id=file_id(src, file),
+                    kind="file",
+                    name=file.rsplit("/", 1)[-1],
+                    qualname=file,
+                    lang="js",
+                    source=src,
+                    file=file,
+                    line=1,
+                    end=facts["lines"],
+                    layer="client",
+                    attrs={"errors": facts["errors"]} if facts["errors"] else {},
+                )
+            )
+            for err in facts["errors"]:
+                g.finding(Finding("parse-error", "error", err["message"], file, err["line"]))
+            for f in facts["functions"]:
+                if f["kind"] == "module":
+                    continue
+                kind = cast(NodeKind, f["kind"] if f["kind"] in ("component", "hook", "method") else "function")
+                g.add_node(
+                    Node(
+                        id=fn_id(src, file, f["id"]),
+                        kind=kind,
+                        name=f["name"],
+                        qualname=f["id"],
+                        lang="js",
+                        source=src,
+                        file=file,
+                        line=f["line"],
+                        end=f["end"],
+                        col=f["col"],
+                        layer="screen" if kind == "component" else "client",
+                        doc=f.get("doc", ""),
+                        tags=["exported"] if f["exported"] else [],
+                        attrs={"params": f["params"]} if f["params"] else {},
+                    )
+                )
+                parent = fn_id(src, file, f["parent"]) if f.get("parent") else file_id(src, file)
+                if f.get("parent") and f["parent"] not in self.fn_index[file]:
+                    parent = file_id(src, file)
+                g.add_edge(Edge(parent, fn_id(src, file, f["id"]), "contains"))
+        for file, facts in self.facts.items():
+            self._imports(file, facts)
+            self._functions(file, facts)
+            self._requests(file, facts)
+            self._pages(file, facts)
+
+    def _imports(self, file: str, facts: dict[str, Any]) -> None:
+        packages: list[str] = []
+        for imp in facts["imports"]:
+            target = self.resolve_module(imp["source"], file)
+            if target and target != file:
+                self.graph.add_edge(
+                    Edge(
+                        file_id(self.source.name, file),
+                        file_id(self.source.name, target),
+                        "imports",
+                        site=Site(file, imp["line"]),
+                    )
+                )
+            elif not target and not imp["source"].startswith("."):
+                pkg = (
+                    imp["source"].split("/")[0]
+                    if not imp["source"].startswith("@")
+                    else "/".join(imp["source"].split("/")[:2])
+                )
+                if pkg not in packages:
+                    packages.append(pkg)
+        if packages:
+            self.graph.nodes[file_id(self.source.name, file)].attrs["packages"] = packages
+
+    def _functions(self, file: str, facts: dict[str, Any]) -> None:
+        src, g = self.source.name, self.graph
+        for f in facts["functions"]:
+            node = file_id(src, file) if f["kind"] == "module" else fn_id(src, file, f["id"])
+            outside: list[str] = []
+            for call in f["calls"]:
+                target, confidence = self.resolve_callee(file, f, call["callee"])
+                if target and target != node and target in g.nodes:
+                    g.add_edge(Edge(node, target, "calls", confidence, site=Site(file, call["line"])))  # type: ignore[arg-type]
+                    self._wrapper_request(node, file, call, target)
+                elif (
+                    not target
+                    and call["callee"].split(".")[0] not in f.get("bindings", {})
+                    and call["callee"] not in outside
+                ):
+                    outside.append(call["callee"])
+            for r in f["renders"]:
+                target = self.component_for(file, r["tag"])
+                if target and target in g.nodes:
+                    g.add_edge(Edge(node, target, "renders", site=Site(file, r["line"])))
+            for name, b in f.get("bindings", {}).items():
+                if b["kind"] == "lazy" and b.get("source"):
+                    target_file = self.resolve_module(b["source"], file)
+                    target = self.resolve_export(target_file, "default") if target_file else None
+                    if target and target in g.nodes:
+                        g.add_edge(Edge(node, target, "uses", site=Site(file, b["line"]), label=f"lazy {name}"))
+            if outside and node in g.nodes:
+                g.nodes[node].attrs["outside"] = outside[:40]
+            if f.get("wrapper") and node in g.nodes:
+                g.nodes[node].attrs["wrapper"] = f["wrapper"]
+
+    def _wrapper_request(self, caller: str, file: str, call: dict[str, Any], target: str) -> None:
+        """`getJSON('/api/items')` where getJSON forwards its first argument to fetch: a request from the caller."""
+        node = self.graph.nodes.get(target)
+        wrapper = node.attrs.get("wrapper") if node else None
+        if not wrapper:
+            tfile, _, tid = target.split(":", 2)[2].partition("#")
+            wrapper = self.fn_index.get(tfile, {}).get(tid, {}).get("wrapper")
+        if not wrapper or wrapper.get("url") != 0 or not call.get("args"):
+            return
+        url = call["args"][0]
+        if not isinstance(url, str) or not (url.startswith("/") or url.startswith("{}") or "://" in url):
+            return
+        prefix = wrapper.get("prefix") or ""
+        if prefix and not url.startswith(prefix):
+            url = prefix.rstrip("/") + "/" + url.lstrip("/")
+        method = (call.get("method") if wrapper.get("optionsArg") is not None else None) or wrapper.get("method") or "?"
+        self.requests.append(
+            Request(
+                caller,
+                method,
+                url.split("?")[0],
+                file,
+                call["line"],
+                "inferred",
+                f"via {target.rsplit('#', 1)[-1]}",
+                source=self.source.name,
+            )
+        )
+
+    def _requests(self, file: str, facts: dict[str, Any]) -> None:
+        src = self.source.name
+        clients = self._imported_clients(file, facts)
+        for h in facts["http"]:
+            node = fn_id(src, file, h["fn"]) if h.get("fn") else file_id(src, file)
+            if node not in self.graph.nodes:
+                node = file_id(src, file)
+            url, confidence = h["url"], h["confidence"]
+            recv = h.get("recv")
+            if recv and recv in clients:
+                kind, base = clients[recv]
+                if h["client"] in ("unknown", "custom", "openapi") and kind in ("axios", "ky", "openapi", "ofetch"):
+                    confidence = "exact"
+                    if base and not url.startswith(base.rstrip("/") + "/"):
+                        url = base.rstrip("/") + "/" + url.lstrip("/")
+            self.requests.append(
+                Request(node, h["method"], url, file, h["line"], confidence, h["client"], h["raw"], src)
+            )
+
+    def _imported_clients(self, file: str, facts: dict[str, Any]) -> dict[str, tuple[str, str | None]]:
+        """Clients created in other files and imported here: `import { http } from '@/lib/http'`."""
+        out: dict[str, tuple[str, str | None]] = {}
+        for imp in facts["imports"]:
+            target = self.resolve_module(imp["source"], file)
+            if not target:
+                continue
+            exported = imp["imported"]
+            target_facts = self.facts[target]
+            local = next((e.get("local") or e["name"] for e in target_facts["exports"] if e["name"] == exported), None)
+            for client in target_facts.get("clients", []):
+                if client["name"] == local:
+                    out[imp["local"]] = (client["kind"], client.get("base"))
+        return out
+
+    def _pages(self, file: str, facts: dict[str, Any]) -> None:
+        src, g = self.source.name, self.graph
+        enabled = set(self.source.frameworks)
+        for r in facts["routes"]:
+            if "auto" not in enabled and r["router"] not in enabled:
+                continue
+            node_id = f"page:{src}:{r['path']}"
+            g.add_node(
+                Node(
+                    id=node_id,
+                    kind="page",
+                    name=r["path"],
+                    qualname=r["path"],
+                    lang="js",
+                    source=src,
+                    file=file,
+                    line=r["line"],
+                    end=r["line"],
+                    col=r["col"],
+                    layer="screen",
+                    tags=[r["router"]],
+                    attrs={"path": r["path"], "router": r["router"]},
+                )
+            )
+            target = None
+            if r.get("component"):
+                target = self.component_for(file, r["component"])
+            elif r.get("lazy"):
+                target_file = self.resolve_module(r["lazy"], file)
+                target = self.resolve_export(target_file, "default") if target_file else None
+            if target and target in g.nodes:
+                g.add_edge(Edge(node_id, target, "routes", site=Site(file, r["line"])))
+                g.nodes[node_id].attrs["component"] = target
+
+
+def build(graph: Graph, source: SourceConfig, project_root: Path, facts: dict[str, dict[str, Any]]) -> JsBuild:
+    builder = JsBuild(graph, source, project_root, facts)
+    builder.run()
+    return builder