code-node-graph 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

code_node/__init__.py

@@ -13,7 +13,7 @@ from .libraries import Library, register_library
 from .platforms import Platform, get_platform, register_platform
 from .project import EntryPoint, Project, entry_points, read_project
 
-__version__ = "0.3.0"
+__version__ = "0.5.0"
 
 __all__ = [
     "CodeGraph",

code_node/analysis/graph.py

@@ -8,14 +8,14 @@ from __future__ import annotations
 import heapq
 import re
 from collections import defaultdict
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 
 from ..kit.fmt import _plural
 from ..kit.text import _clip
 
 from .syntax import _a
 from .aws_model import _service_name
-from .model import AwsCall, CodeFunction, CodeMap, CodeSpot, CodeStep, LibraryCall
+from .model import AwsCall, CodeFunction, CodeMap, CodeSpot, CodeStep, History, LibraryCall
 from .findings import _listed, _short_name
 from ..platforms import get_platform
 
@@ -55,6 +55,8 @@ class GraphNode:
     when: str = ""  # a function called only under an if, everywhere it's called: 'check(order)'
     icon: str = ""  # a service's icon, when its plugin names one: 'database', 'queue', 'spark'; or the entry
     # point's logo, when its platform names one: 'fastapi-icon'
+    name: str = ""  # a function's box: the function, as module.name ('orders.repo.save')
+    history: History | None = None  # a function's box: what git says about its lines
 
 
 @dataclass
@@ -85,6 +87,7 @@ class CodeGraph:
     nodes: list[GraphNode] = field(default_factory=list)
     edges: list[GraphEdge] = field(default_factory=list)
     hidden: int = 0  # functions left out to keep the graph readable (too deep, or too many)
+    too_deep: int = 0  # ...of them, the ones deeper than it draws
 
     def node(self, node_id: str) -> GraphNode | None:
         return next((n for n in self.nodes if n.id == node_id), None)
@@ -256,11 +259,13 @@ def _pick(
     order: dict[str, int],
     room: int,
     max_depth: int,
+    first: bool = False,
 ) -> list[str]:
     """
     The functions the graph draws besides the entry point, at most `room` of them and max_depth calls deep: grown out
     from the entry point (and what runs at import), each time taking the one the drawn boxes call that leads to the
-    most code, so the boxes are the ones that do the work and each is joined to one above it.
+    most code, so the boxes are the ones that do the work and each is joined to one above it. first takes every
+    function the entry point calls before the rest.
     """
 
     def depth(name: str) -> int:
@@ -283,6 +288,14 @@ def _pick(
         if name not in level:
             offer(name)
     picked: list[str] = []
+    if first:
+        for child, _ in children.get(entry, []):
+            if child in by_name and child != entry and child not in picked and depth(child) <= max_depth:
+                picked.append(child)
+        for name in list(picked):
+            for child, _ in children.get(name, []):
+                if child not in picked:
+                    offer(child)
     while queue and len(picked) < room:
         name = heapq.heappop(queue)[3]
         if name in picked:
@@ -294,7 +307,46 @@ def _pick(
     return picked
 
 
-def code_graph(cmap: CodeMap, *, max_functions: int = _GRAPH_FUNCTIONS, max_depth: int = _GRAPH_DEPTH) -> CodeGraph:
+def _focused(cmap: CodeMap, focus: str) -> CodeMap:
+    """
+    The map cut down to one of its functions and what it calls, however deep, as if the code started there: its
+    calls in from elsewhere, what runs at import and the entry point's input left out.
+    """
+    children: dict[str, list[str]] = defaultdict(list)
+    for f in cmap.functions:
+        for where in f.called_from:
+            children[where.rpartition(" line ")[0]].append(f.name)
+    scope, todo = {focus}, [focus]
+    while todo:
+        for child in children.get(todo.pop(), []):
+            if child not in scope:
+                scope.add(child)
+                todo.append(child)
+    root = next(f for f in cmap.functions if f.name == focus)
+    functions = []
+    for f in cmap.functions:
+        if f.name in scope:
+            kept = [] if f.name == focus else [w for w in f.called_from if w.rpartition(" line ")[0] in scope]
+            functions.append(replace(f, called_from=kept, when={w: t for w, t in f.when.items() if w in kept}))
+    return replace(
+        cmap,
+        entry=focus,
+        handler_file=root.file,
+        entry_line=root.line,
+        startup=[],
+        event=[],
+        functions=functions,
+        aws=[c for c in cmap.aws if c.function in scope],
+        library_calls=[c for c in cmap.library_calls if c.function in scope],
+        env=[e for e in cmap.env if e.function in scope],
+        spots=[s for s in cmap.spots if s.function in scope and not s.startup],
+        routes=[r for r in cmap.routes if r[2] in scope],
+    )
+
+
+def code_graph(
+    cmap: CodeMap, *, max_functions: int = _GRAPH_FUNCTIONS, max_depth: int = _GRAPH_DEPTH, focus: str = ""
+) -> CodeGraph:
     """
     How the code fits together, as boxes and arrows, from a CodeMap: on the left what comes in (the event, with the
     fields it reads, and the environment variables), then the handler, what runs at start-up, and its own functions
@@ -304,10 +356,16 @@ def code_graph(cmap: CodeMap, *, max_functions: int = _GRAPH_FUNCTIONS, max_dept
     they do is drawn from the nearest box above them that is.
     The functions drawn are grown out from the entry point, each time the one that leads to the most code (and to AWS,
     the web and the environment), so the boxes are the ones that do the work, not the nearest helpers.
+    focus draws the graph from one of its functions instead (module.name): it and what it calls, every call it makes
+    drawn even past max_functions, and nothing from what comes in or what runs at import.
     """
     graph = CodeGraph()
     if cmap.note or cmap.entry is None:
         return graph
+    if focus:
+        if not any(f.name == focus for f in cmap.functions):
+            return graph
+        cmap = _focused(cmap, focus)
     platform = get_platform(cmap.platform)
     entry = cmap.entry
     by_name = {f.name: f for f in cmap.functions}
@@ -342,11 +400,15 @@ def code_graph(cmap: CodeMap, *, max_functions: int = _GRAPH_FUNCTIONS, max_dept
                 todo.append(child)
     order = {f.name: i for i, f in enumerate(cmap.functions)}
     weight = _weights(cmap, children)
-    picked = _pick(cmap, entry, start_key, children, level, weight, order, max_functions - entry_is_function, max_depth)
+    room = max_functions - entry_is_function
+    if focus:  # a function opened on its own shows every call it makes
+        room = max(room, len({child for child, _ in children.get(entry, [])}))
+    picked = _pick(cmap, entry, start_key, children, level, weight, order, room, max_depth, first=bool(focus))
     shown = ([by_name[entry]] if entry_is_function else []) + sorted(
         (by_name[name] for name in picked), key=lambda f: (level.get(f.name, f.depth + 1), order[f.name])
     )
     graph.hidden = len(cmap.functions) - len(shown)
+    graph.too_deep = sum(1 for f in cmap.functions if level.get(f.name, f.depth + 1) > max_depth)
     ids = {f.name: f"f{i}" for i, f in enumerate(shown)}
     drawn_level = {entry: 0, start_key: 0}  # calls from the entry point through the boxes drawn: each box's column
     todo = [entry, start_key]
@@ -408,7 +470,9 @@ def code_graph(cmap: CodeMap, *, max_functions: int = _GRAPH_FUNCTIONS, max_dept
             reasons[call.function].append(f"{call.label} isn't allowed: {denied[call.permission]} (line {call.line})")
     for function, why in platform.marks(cmap).items():
         reasons[function] += why
-    handler_reasons = [m.split(":")[0] for level_, m in platform.entry_findings(cmap) if level_ == "warn"]
+    handler_reasons = (
+        [] if focus else [m.split(":")[0] for level_, m in platform.entry_findings(cmap) if level_ == "warn"]
+    )
     unset = platform.unset_env(cmap)
 
     # the lines in each function worth pointing at: where it calls, reads or sends what the graph draws
@@ -455,7 +519,7 @@ def code_graph(cmap: CodeMap, *, max_functions: int = _GRAPH_FUNCTIONS, max_dept
                     when=_when(f, [where for where in f.called_from if where.rpartition(" line ")[0] == caller]),
                 )
             )
-    has_input = bool(cmap.event) or platform.draws_input
+    has_input = not focus and (bool(cmap.event) or platform.draws_input)
     if has_input:
         edges.insert(0, GraphEdge("event", entry_id, "event", "its input"))
 
@@ -769,7 +833,9 @@ def code_graph(cmap: CodeMap, *, max_functions: int = _GRAPH_FUNCTIONS, max_dept
                 ],
                 more=more,
                 when=_when(f, f.called_from),
-                icon=platform.entry_icon(cmap) if is_entry else "",
+                icon=platform.entry_icon(cmap) if is_entry and not focus else "",
+                name=f.name,
+                history=f.history,
             )
         )
     out_column = 1 + max([n.column for n in graph.nodes if n.kind in ("handler", "function", "start")] + [1])
@@ -778,3 +844,80 @@ def code_graph(cmap: CodeMap, *, max_functions: int = _GRAPH_FUNCTIONS, max_dept
     graph.nodes += reach
     graph.edges = edges
     return graph
+
+
+_GRAPH_VIEWS = 120  # functions opened on their own, at most: past that a box's calls left out stay in the steps
+
+_GRAPH_EVERYTHING = 150  # functions, at most, for a graph of all of them besides the one drawn
+
+
+@dataclass
+class GraphView:
+    """
+    The graph from one of the functions a graph leaves calls out of: the function and what it calls (`graph`), and the
+    calls from the entry point down to it (`path`, module.name each, the entry point first and the function last).
+    """
+
+    name: str
+    graph: CodeGraph
+    path: list[str] = field(default_factory=list)
+
+
+def _call_path(cmap: CodeMap, name: str) -> list[str]:
+    """
+    The fewest calls from the entry point to a function: [entry, ..., name]. [name] when the entry point isn't above it.
+    """
+    known = {f.name for f in cmap.functions} | {cmap.entry or ""}
+    parents: dict[str, list[str]] = defaultdict(list)
+    for f in cmap.functions:
+        for where in f.called_from:
+            caller = where.rpartition(" line ")[0]
+            if caller in known:
+                parents[f.name].append(caller)
+    came: dict[str, str] = {name: ""}
+    todo = [name]
+    while todo:
+        key = todo.pop(0)
+        if key == cmap.entry:
+            path = [key]
+            while came[path[-1]]:
+                path.append(came[path[-1]])
+            return path
+        for parent in parents.get(key, []):
+            if parent not in came:
+                came[parent] = key
+                todo.append(parent)
+    return [name]
+
+
+def graph_views(
+    cmap: CodeMap,
+    graph: CodeGraph,
+    *,
+    max_functions: int = _GRAPH_FUNCTIONS,
+    max_depth: int = _GRAPH_DEPTH,
+    most: int = _GRAPH_VIEWS,
+) -> list[GraphView]:
+    """
+    A graph from each function whose calls `graph` leaves out, and from each such function in those, so that from any
+    box with calls not drawn, its own graph has them: at most `most`, nearest the entry point first.
+    """
+    views: dict[str, GraphView] = {}
+    todo = [graph]
+    while todo and len(views) < most:
+        for n in todo.pop(0).nodes:
+            if not (n.more and n.name) or n.name in views or len(views) >= most:
+                continue
+            opened = code_graph(cmap, max_functions=max_functions, max_depth=max_depth, focus=n.name)
+            views[n.name] = GraphView(n.name, opened, _call_path(cmap, n.name))
+            todo.append(opened)
+    return list(views.values())
+
+
+def everything_graph(cmap: CodeMap, graph: CodeGraph, most: int = _GRAPH_EVERYTHING) -> CodeGraph | None:
+    """
+    Every function in one graph, when `graph` leaves some out and there are at most `most` of them; else None.
+    """
+    if not graph.hidden or len(cmap.functions) > most:
+        return None
+    return code_graph(cmap, max_functions=len(cmap.functions) + 1, max_depth=len(cmap.functions) + 1)

code_node/analysis/model.py

@@ -173,6 +173,50 @@ class EventField:
         return _event_label(self.path)
 
 
+@dataclass
+class Commit:
+    """
+    A commit, as git blame tells it.
+    """
+
+    sha: str
+    author: str
+    time: int  # when it was made, in seconds since 1970
+    subject: str  # its message's first line
+    url: str = ""  # its page on the repository's host, when that's GitHub or GitLab
+
+    @property
+    def short(self) -> str:
+        return self.sha[:7]
+
+
+@dataclass
+class History:
+    """
+    What git says about a function's lines as they are now: the commit that last changed one of them, how many commits
+    and people they come from, and how many have changed since the last commit. Read by history.py; None on a
+    function when the folder isn't in git.
+    """
+
+    last: Commit | None  # the newest commit among its lines; None when none of them is committed yet
+    commits: int  # the commits its lines come from
+    authors: list[str]  # who wrote them, most lines first
+    first: int  # when the oldest of them was made (about when the function was written), in seconds since 1970
+    uncommitted: int  # its lines changed since the last commit
+    now: int  # when this was read, for 'three days ago'
+
+    def ago(self, time: int) -> str:
+        """
+        'today', '3 days ago', '2 months ago', '1 year ago'.
+        """
+        days = max(0, self.now - time) // 86_400
+        for size, unit in ((365, "year"), (30, "month"), (7, "week"), (1, "day")):
+            if days >= size:
+                count = days // size
+                return f"{count} {unit}{'' if count == 1 else 's'} ago"
+        return "today"
+
+
 @dataclass
 class CodeFunction:
     """
@@ -190,6 +234,7 @@ class CodeFunction:
     # nearest around the call, else the nearest `if x: return` above it ('args.serve', not every check before it)
     depth: int = 0  # calls from the entry point (the entry point is 0)
     is_async: bool = False  # async def: a call that blocks in it holds up everything else on its event loop
+    history: History | None = None  # what git says about its lines, when the folder is in git (history.py)
 
 
 @dataclass

code_node/analysis/reader.py

@@ -203,6 +203,22 @@ class _CodeReader:
             module = module[: -len(".__init__")] if module.endswith(".__init__") else module
             if module and module != "__init__":
                 self.sources[module] = path
+        here = (cmap.handler_file or "").rpartition("/")[0]
+        here = here + "/" if here else ""
+        if here.startswith(root) and here != root:
+            # the entry point's own folder is on sys.path too, as a script's is and a Lambda function's code is:
+            # `from helpers import x` beside it is its own code, though the folder is also a package from the root
+            beside: set[str] = set()
+            for path in texts:
+                if not path.startswith(here) or not path.endswith(".py") or "site-packages" in path:
+                    continue
+                module = path[len(here) : -3].replace("/", ".")
+                module = module[: -len(".__init__")] if module.endswith(".__init__") else module
+                if module and module != "__init__" and "-" not in module and module not in self.sources:
+                    self.sources[module] = path
+                    beside.add(module.split(".")[0])
+            self.tops |= beside
+            self.libraries = libraries - beside
         self.modules: dict[str, _Module] = {}
         self.defs: dict[str, tuple[str, Any, str | None]] = {}  # key -> (module, node, class key)
         self.classes: dict[str, dict[str, Any]] = {}
@@ -311,8 +327,9 @@ class _CodeReader:
         cmap.event = list(self.event_reads.values())
         cmap.routes = [(method, path, key) for method, path, key, _ in self.routes]
         loaded = [m for m in self.modules.values() if m.tree is not None]
-        cmap.other_files = sum(
-            1 for name, path in self.sources.items() if name not in self.modules and not _JUNK_RE.search(path)
+        read = {path for name, path in self.sources.items() if name in self.modules}  # a file has two names, at most
+        cmap.other_files = len(
+            {path for path in self.sources.values() if path not in read and not _JUNK_RE.search(path)}
         )
         for m in loaded:
             for node in m.tree.body:
@@ -324,7 +341,7 @@ class _CodeReader:
                     if isinstance(f, (ast.FunctionDef, ast.AsyncFunctionDef)) and prefix + f.name not in self.reached
                 )
             self._secrets(m)
-        for name, path in self.sources.items():
+        for path, name in {path: name for name, path in reversed(self.sources.items())}.items():
             for match in _AWS_KEY_RE.finditer(self.texts[path]):
                 line = self.texts[path].count("\n", 0, match.start()) + 1
                 self._spot("secret", path, line, name, "", "an AWS access key", ok=False)

code_node/cli.py

@@ -99,6 +99,9 @@ def _parse_args(argv: list[str] | None) -> argparse.Namespace:
         default="vscode",
         help="the editor the page's line links open (default vscode; none for no links)",
     )
+    parser.add_argument(
+        "--no-git", action="store_true", help="leave out what git says about each function (who changed it, when)"
+    )
     return parser.parse_args(argv)
 
 
@@ -286,7 +289,12 @@ def main(argv: list[str] | None = None) -> int:
     if entry is None:
         return 1
     options = PageOptions(
-        draw_all=args.all, functions=args.functions, depth=args.depth, platform=args.platform, editor=args.editor
+        draw_all=args.all,
+        functions=args.functions,
+        depth=args.depth,
+        platform=args.platform,
+        editor=args.editor,
+        git=not args.no_git,
     )
     if args.mermaid:
         print(make_mermaid(project.root, entry, options))

code_node/history.py

@@ -0,0 +1,151 @@
+"""
+What git says about the functions a map shows: `git blame` on the lines of each one, once per file, for the commit
+that last changed it, how many commits and people its lines come from, and the lines changed since the last commit.
+
+git is run on the folder, never the code in it, and only to read: blame with no text conversion and no file system
+monitor. A folder whose own git config names a filter command (one git would run on the files) isn't read at all.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+import time
+from collections import Counter
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+from .analysis.model import CodeFunction, Commit, History
+
+_TIMEOUT = 20  # seconds a git command may take before its file goes without history
+
+_WORKERS = 8  # files blamed at once
+
+_UNCOMMITTED = "0" * 40  # the commit blame gives lines changed since the last one
+
+_HOSTS = {"github.com": "{}/commit/{}", "gitlab.com": "{}/-/commit/{}"}  # a commit's page, by host
+
+_SAFE = ["-c", "core.fsmonitor=false", "--no-pager"]  # no program of the folder's config runs
+
+
+def _git(root: Path, *args: str) -> str | None:
+    """
+    What a git command prints, run in root; None when git isn't there or fails (not a repository, a file it doesn't
+    track, a folder it doesn't trust).
+    """
+    try:
+        done = subprocess.run(
+            ["git", *_SAFE, "-C", str(root), *args],
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=_TIMEOUT,
+            env={**os.environ, "GIT_TERMINAL_PROMPT": "0", "GIT_OPTIONAL_LOCKS": "0"},
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    return done.stdout if done.returncode == 0 else None
+
+
+def _runs_filters(root: Path) -> bool:
+    """
+    Whether the folder's own git config (not the user's) names a filter command, which blame would run on its files.
+    """
+    found = _git(root, "config", "--show-scope", "--get-regexp", r"^filter\..*\.(clean|process)$")
+    return any(line.split("\t", 1)[0] in ("local", "worktree") for line in (found or "").splitlines())
+
+
+def _commit_page(remote: str) -> str:
+    """
+    The repository's web address with a {} for the sha, from its origin: 'https://github.com/o/r/commit/{}'.
+    """
+    found = re.fullmatch(r"(?:https?://(?:[^@/]+@)?|ssh://(?:[^@/]+@)?|[^@/]+@)([^/:]+)[:/](.+?)(?:\.git)?/?", remote)
+    if not found or found.group(1) not in _HOSTS:
+        return ""
+    return _HOSTS[found.group(1)].format(f"https://{found.group(1)}/{found.group(2)}", "{}")
+
+
+def _blame(root: Path, file: str, start: int, end: int) -> dict[int, tuple[str, dict[str, str]]]:
+    """
+    Each line from start to end of the file as it is now: line -> (the commit it comes from, that commit's headers).
+    """
+    out = _git(root, "blame", "--porcelain", "--no-textconv", "-L", f"{start},{end}", "--", file)
+    lines: dict[int, tuple[str, dict[str, str]]] = {}
+    if not out:
+        return lines
+    headers: dict[str, dict[str, str]] = {}
+    sha = ""
+    for row in out.splitlines():
+        if row.startswith("\t"):
+            continue
+        parts = row.split(" ")
+        if len(parts) >= 3 and len(parts[0]) == 40 and parts[1].isdigit() and parts[2].isdigit():
+            sha = parts[0]
+            headers.setdefault(sha, {})
+            lines[int(parts[2])] = (sha, headers[sha])
+        elif sha:
+            key, _, value = row.partition(" ")
+            headers[sha].setdefault(key, value)
+    return lines
+
+
+def _history(blamed: dict[int, tuple[str, dict[str, str]]], start: int, end: int, page: str, now: int) -> History:
+    """
+    A function's history from its lines' blame.
+    """
+    commits: dict[str, Commit] = {}
+    by_author: Counter[str] = Counter()
+    uncommitted = 0
+    for k in range(start, end + 1):
+        if k not in blamed:
+            continue
+        sha, said = blamed[k]
+        if sha == _UNCOMMITTED:
+            uncommitted += 1
+            continue
+        if sha not in commits:
+            commits[sha] = Commit(
+                sha,
+                said.get("author", "?"),
+                int(said.get("author-time", "0") or 0),
+                said.get("summary", ""),
+                page.format(sha) if page else "",
+            )
+        by_author[commits[sha].author] += 1
+    last = max(commits.values(), key=lambda c: c.time, default=None)
+    return History(
+        last=last,
+        commits=len(commits),
+        authors=[name for name, _ in by_author.most_common()],
+        first=min((c.time for c in commits.values()), default=0),
+        uncommitted=uncommitted,
+        now=now,
+    )
+
+
+def read_history(root: Path, functions: list[CodeFunction]) -> int:
+    """
+    Fills in each function's history from git, blaming each file once over the lines its functions take up. How many
+    functions it found history for: 0 when the folder isn't in git, git isn't installed, or the folder's config would
+    have git run a program of its own.
+    """
+    spans: dict[str, tuple[int, int]] = {}
+    for f in functions:
+        if f.file and f.line and f.lines:
+            start, end = spans.get(f.file, (f.line, f.line + f.lines - 1))
+            spans[f.file] = (min(start, f.line), max(end, f.line + f.lines - 1))
+    if not spans or _git(root, "rev-parse", "--is-inside-work-tree") is None or _runs_filters(root):
+        return 0
+    page = _commit_page((_git(root, "remote", "get-url", "origin") or "").strip())
+    now = int(time.time())
+    with ThreadPoolExecutor(max_workers=min(_WORKERS, len(spans))) as pool:
+        blamed = dict(zip(spans, pool.map(lambda file: _blame(root, file, *spans[file]), spans)))
+    found = 0
+    for f in functions:
+        lines = blamed.get(f.file)
+        if lines:
+            f.history = _history(lines, f.line, f.line + f.lines - 1, page, now)
+            found += 1
+    return found

code_node/pages.py

@@ -6,13 +6,14 @@ once, and the server makes it again on every change.
 from __future__ import annotations
 
 import os
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from pathlib import Path
 
 from .analysis.graph import code_graph
 from .analysis.mapping import entry_file, map_code
 from .analysis.model import CodeMap
 from .deploys import find_deployment
+from .history import read_history
 from .project import EntryPoint, Project, read_project
 from .report.build import page_blocks
 from .report.editor import editor_link
@@ -38,6 +39,7 @@ class PageOptions:
     depth: int = GRAPH_DEPTH
     platform: str = ""  # --platform: its checks run whatever the entry point is ('' leaves it to the entry point)
     editor: str = "vscode"  # --editor: the editor its line links open ('vscode', 'cursor'; 'none' for no links)
+    git: bool = True  # what git says about each function (--no-git leaves it out)
 
     @property
     def limits(self) -> tuple[int, int]:
@@ -63,6 +65,8 @@ def map_entry(root: Path, entry: EntryPoint, options: PageOptions) -> tuple[Code
         platform=options.platform or entry.platform,
         deployment=deployment,
     )
+    if options.git:
+        read_history(project.root, cmap.functions)
     return cmap, project
 
 
@@ -87,6 +91,6 @@ def make_mermaid(root: Path, entry: EntryPoint, options: PageOptions) -> str:
     """
     The graph as Mermaid.
     """
-    cmap, _ = map_entry(root, entry, options)
+    cmap, _ = map_entry(root, entry, replace(options, git=False))  # Mermaid has nowhere to say it
     max_functions, max_depth = options.limits
     return code_graph(cmap, max_functions=max_functions, max_depth=max_depth).mermaid()

code_node/report/build.py

@@ -10,7 +10,7 @@ from ..kit.blocks import _Note, _Text
 from ..kit.fmt import _plural
 
 from ..analysis.findings import _listed, _short_name
-from ..analysis.graph import CodeGraph, code_graph
+from ..analysis.graph import CodeGraph, code_graph, everything_graph, graph_views
 from ..analysis.model import CodeMap
 from .graph import _Graph
 from .tabs import _Tabs
@@ -34,8 +34,8 @@ def _closing_note(cmap: CodeMap, graph: CodeGraph) -> str:
         said.append(f"Calls to {_listed(services, 4)} are read by code-node's library plugins.")
     if graph.hidden:
         said.append(
-            f"The graph leaves out {_plural(graph.hidden, 'function')} to stay readable: run with --all to "
-            "draw every one."
+            f"The graph leaves out {_plural(graph.hidden, 'function')} to stay readable: a box's line of calls not "
+            "drawn opens them, and --all draws every one."
         )
     if cmap.other_files:
         said.append(
@@ -99,6 +99,8 @@ def page_blocks(
                         "How it fits together: what comes in, who calls whom, and what it reaches",
                         sources=sources or {},
                         editor=editor,
+                        views=graph_views(cmap, graph, max_functions=max_functions, max_depth=max_depth),
+                        everything=everything_graph(cmap, graph),
                     ),
                     _Text(
                         graph.mermaid(),

code_node/report/changes.py

@@ -0,0 +1,42 @@
+"""
+What git says about a function, as HTML: who changed it last and when, with a link to the commit when the repository
+is on GitHub or GitLab, how many commits and people its lines come from, and its lines not committed yet. The same
+in the graph's panel, its hover card and the walk's card.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+from ..kit.text import _esc
+
+from ..analysis.model import History
+
+
+def history_html(history: History | None, short: bool = False) -> str:
+    """
+    The function's history as a few lines, or '' without one. short: the last change alone, for a hover card.
+    """
+    if history is None or not (history.last or history.uncommitted):
+        return ""
+    said = []
+    last = history.last
+    if last:
+        day = datetime.fromtimestamp(last.time, timezone.utc).strftime("%Y-%m-%d")
+        sha = f"<code>{_esc(last.short)}</code>"
+        if last.url and not short:
+            sha = f'<a href="{_esc(last.url)}" target="_blank" rel="noopener" title="The commit">{sha} ↗</a>'
+        said.append(
+            f'Last changed <b title="{day}">{_esc(history.ago(last.time))}</b> by {_esc(last.author)} in {sha}'
+            + (f": <q>{_esc(last.subject)}</q>" if last.subject else "")
+        )
+        if history.commits > 1 and not short:
+            people = f"{len(history.authors)} people" if len(history.authors) > 1 else _esc(history.authors[0])
+            said.append(
+                f"Its lines come from {history.commits} commits by {people}, the oldest "
+                f"{_esc(history.ago(history.first))}"
+            )
+    if history.uncommitted:
+        changed = f"{history.uncommitted} line{'' if history.uncommitted == 1 else 's'} changed since the last commit"
+        said.append(f'<span class="cnhu">{changed if last else "Not committed yet"}</span>')
+    return '<div class="cnh">' + "".join(f"<p>{line}</p>" for line in said) + "</div>"