code-node-graph 0.4.0__tar.gz → 0.6.0__tar.gz

{code_node_graph-0.4.0 → code_node_graph-0.6.0}/CHANGELOG.md

@@ -4,6 +4,38 @@ Every change a user would notice, newest first ([Keep a Changelog](https://keepa
 follow [Semantic Versioning](https://semver.org/); before 1.0, a minor version may change what a command does.
 ## [Unreleased]
 
+## [0.6.0] - 2026-10-20
+
+### Changed
+
+- A function's code panel says beside each line who changed it last and how long ago ("Asha · 3d"), with a bar
+  that's darker the newer the line and amber for a line not committed yet. Its last row says when the function was
+  last changed, by whom, in which commit, and how many commits and people it comes from; point at a line and it says
+  that line's commit instead. The gear by × opens the panel's settings, where the history can be turned off; the
+  page remembers that. The panel's head is plainer: the name, then what it is, where, and a link to open it in your
+  editor, without the def repeated over the code.
+- Code on the page is set in Cascadia Code when it's installed, before Cascadia Mono and the system's monospace
+  font, and the docs site's code is in Cascadia Code instead of IBM Plex Mono.
+
+## [0.5.0] - 2026-10-20
+
+### Added
+
+- The graph moves like a canvas: drag it to pan in any direction, hold Ctrl (⌘ on a Mac) and scroll, or pinch a
+  trackpad, to zoom around the pointer, and `+`, `-` and `0` when it has focus. It stays in a box as wide as the page and
+  about the window's height, however far it's zoomed, so the scroll bar under a tall graph is no longer the only way across;
+  **Fit** puts all of it in that box, and − and + buttons in its corner say how big it's drawn. This needs JavaScript;
+  without it the graph scrolls as before.
+
+- Each function says what git says about it, when the folder is in git: who changed it last, how long ago and in
+  which commit (a link to the commit on GitHub or GitLab), how many commits and people its lines come from, and how
+  many of its lines changed since the last commit. It's in a box's hover card and code panel and in the step that
+  goes into it. It's read with `git blame`, once per file; `--no-git` leaves it out.
+
+### Changed
+
+- A box's code opens in a panel over the graph, rather than pushing the graph aside on a wide screen.
+
 ## [0.4.0] - 2026-10-20
 
 ### Fixed
@@ -193,7 +225,9 @@ follow [Semantic Versioning](https://semver.org/); before 1.0, a minor version m
 - `--platform NAME` runs a platform's checks whatever the entry point is; `--lambda` is short for
   `--platform lambda`. `EntryPoint.is_lambda` and `PageOptions.is_lambda` are now `platform` (`"lambda"` or `""`).
 
-[Unreleased]: https://github.com/utkarsh5026/code-node/compare/v0.4.0...HEAD
+[Unreleased]: https://github.com/utkarsh5026/code-node/compare/v0.6.0...HEAD
+[0.6.0]: https://github.com/utkarsh5026/code-node/compare/v0.5.0...v0.6.0
+[0.5.0]: https://github.com/utkarsh5026/code-node/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/utkarsh5026/code-node/compare/v0.3.0...v0.4.0
 [0.3.0]: https://github.com/utkarsh5026/code-node/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/utkarsh5026/code-node/compare/v0.1.0...v0.2.0

{code_node_graph-0.4.0 → code_node_graph-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-node-graph
-Version: 0.4.0
+Version: 0.6.0
 Summary: See how Python code works without running it: a graph of who calls whom from an entry point, and what each path reaches.
 Project-URL: Homepage, https://github.com/utkarsh5026/code-node
 Project-URL: Documentation, https://utkarsh5026.github.io/code-node/
@@ -117,6 +117,7 @@ string is flagged.
 | `-o`, `--out`, `--no-open` | Where to save (default `~/.cache/code-node/`), and whether to open it |
 | `--platform NAME`, `--lambda` | Run a platform's checks on any entry point |
 | `--editor vscode\|cursor\|none` | Editor the line links open (default `vscode`, WSL-aware) |
+| `--no-git` | Leave out what git says about each function (who changed it last, when, in which commit) |
 
 </details>
 

{code_node_graph-0.4.0 → code_node_graph-0.6.0}/README.md

@@ -87,6 +87,7 @@ string is flagged.
 | `-o`, `--out`, `--no-open` | Where to save (default `~/.cache/code-node/`), and whether to open it |
 | `--platform NAME`, `--lambda` | Run a platform's checks on any entry point |
 | `--editor vscode\|cursor\|none` | Editor the line links open (default `vscode`, WSL-aware) |
+| `--no-git` | Leave out what git says about each function (who changed it last, when, in which commit) |
 
 </details>
 

{code_node_graph-0.4.0 → code_node_graph-0.6.0}/src/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.4.0"
+__version__ = "0.6.0"
 
 __all__ = [
     "CodeGraph",

{code_node_graph-0.4.0 → code_node_graph-0.6.0}/src/code_node/analysis/graph.py

@@ -15,7 +15,7 @@ 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
 
@@ -56,6 +56,7 @@ class GraphNode:
     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
@@ -834,6 +835,7 @@ def code_graph(
                 when=_when(f, f.called_from),
                 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])

{code_node_graph-0.4.0 → code_node_graph-0.6.0}/src/code_node/analysis/model.py

@@ -173,6 +173,62 @@ 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'
+    lines: dict[int, Commit | None] = field(default_factory=dict)  # each of its lines -> the commit it comes from,
+    # None for one changed since the last commit
+
+    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"
+
+    def since(self, time: int) -> str:
+        """
+        The same, short, for beside a line: 'today', '3d', '2w', '5mo', '1y'.
+        """
+        days = max(0, self.now - time) // 86_400
+        for size, unit in ((365, "y"), (30, "mo"), (7, "w"), (1, "d")):
+            if days >= size:
+                return f"{days // size}{unit}"
+        return "today"
+
+
 @dataclass
 class CodeFunction:
     """
@@ -190,6 +246,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_graph-0.4.0 → code_node_graph-0.6.0}/src/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_graph-0.6.0/src/code_node/history.py

@@ -0,0 +1,156 @@
+"""
+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, the lines changed since the last commit, and
+the commit each line comes from.
+
+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
+    lines: dict[int, Commit | None] = {}
+    for k in range(start, end + 1):
+        if k not in blamed:
+            continue
+        sha, said = blamed[k]
+        if sha == _UNCOMMITTED:
+            uncommitted += 1
+            lines[k] = None
+            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
+        lines[k] = commits[sha]
+    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,
+        lines=lines,
+    )
+
+
+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_graph-0.4.0 → code_node_graph-0.6.0}/src/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_graph-0.6.0/src/code_node/report/changes.py

@@ -0,0 +1,116 @@
+"""
+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 hover card and the walk's card, and in the graph's panel line by line, beside its code.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+from ..kit.text import _esc
+
+from ..analysis.model import Commit, 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>"
+
+
+_AGES = 4  # shades of a line's bar, oldest to newest
+
+
+def blame_keys(history: History) -> dict[str, int]:
+    """
+    The commits its lines come from, oldest first, each with its place in that order: what a line's mark names to
+    find its commit in the panel's last row.
+    """
+    commits = {c.sha: c for c in history.lines.values() if c}
+    return {sha: k for k, sha in enumerate(sorted(commits, key=lambda sha: (commits[sha].time, sha)))}
+
+
+def blame_mark(history: History, line: int, keys: dict[str, int], same: bool) -> str:
+    """
+    What goes beside a line of the panel's code: who changed it last and how long ago (left out when the line above
+    says the same, same), over a bar darker the newer the line, amber for one not committed yet. Pointing at it says
+    the commit; '' for a line blame didn't cover, so the code stays in line.
+    """
+    if line not in history.lines:
+        return '<span class="sb"></span>'
+    commit = history.lines[line]
+    if commit is None:
+        return (
+            f'<span class="sb au{" same" if same else ""}" data-k="u" title="Changed since the last commit">'
+            "<span>Uncommitted</span></span>"
+        )
+    k = keys[commit.sha]
+    shade = _AGES - 1 if len(keys) == 1 else round(k * (_AGES - 1) / (len(keys) - 1))
+    said = f"{commit.subject} · {commit.author}, {history.ago(commit.time)} · {commit.short}"
+    return (
+        f'<span class="sb a{shade}{" same" if same else ""}" data-k="{k}" title="{_esc(said)}">'
+        f"<span>{_esc(commit.author.split(' ')[0] or commit.author)} · {_esc(history.since(commit.time))}</span></span>"
+    )
+
+
+def blame_row(history: History, keys: dict[str, int]) -> str:
+    """
+    The panel's last row: when its code was last changed and by whom, then hidden, a row for each commit its lines come
+    from, which a script shows in its place while a line from that commit is pointed at.
+    """
+
+    def sha(commit: Commit) -> str:
+        short = f"<code>{_esc(commit.short)}</code>"
+        if not commit.url:
+            return f'<span class="csfh">{short}</span>'
+        return (
+            f'<a class="csfh" href="{_esc(commit.url)}" target="_blank" rel="noopener" title="The commit">{short}</a>'
+        )
+
+    last = history.last
+    if last:
+        day = datetime.fromtimestamp(last.time, timezone.utc).strftime("%Y-%m-%d")
+        said = f'Changed <b title="{day}">{_esc(history.ago(last.time))}</b> by {_esc(last.author)}'
+        if history.commits > 1:
+            people = len(history.authors)
+            said += f" · {history.commits} commits" + (f" by {people} people" if people > 1 else "")
+    else:
+        said = "Not committed yet"
+    if history.uncommitted and last:
+        lines = f"{history.uncommitted} line{'' if history.uncommitted == 1 else 's'}"
+        said += f' · <span class="cnhu">{lines} not committed</span>'
+    rows = [f'<p class="csfs"><span>{said}</span>{sha(last) if last else ""}</p>']
+    commits = {c.sha: c for c in history.lines.values() if c}
+    for found, k in keys.items():
+        commit = commits[found]
+        rows.append(
+            f'<p data-k="{k}" hidden><span><b>{_esc(commit.subject or commit.short)}</b> · {_esc(commit.author)}, '
+            f"{_esc(history.ago(commit.time))}</span>{sha(commit)}</p>"
+        )
+    if history.uncommitted:
+        rows.append('<p data-k="u" hidden><span class="cnhu">Changed since the last commit</span></p>')
+    return f'<div class="csf">{"".join(rows)}</div>'