vgt 0.0.1a0__tar.gz

vgt-0.0.1a0/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: vgt
+Version: 0.0.1a0
+Summary: TUI git viewer
+Home-page: https://www.mlx-code.com
+Author: J Joe
+Author-email: albersj66@gmail.com
+License: Apache-2.0
+Project-URL: Source, https://github.com/JosefAlbers/mlx-code
+Project-URL: Issues, https://github.com/JosefAlbers/mlx-code/issues
+Project-URL: Documentation, https://www.mlx-code.com/
+Requires-Python: >=3.12.8
+Description-Content-Type: text/markdown
+Requires-Dist: textual>=8.2.7
+Requires-Dist: rich>=15.0.0
+Provides-Extra: all
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+view git

vgt-0.0.1a0/README.md

@@ -0,0 +1 @@
+view git

vgt-0.0.1a0/main.py

@@ -0,0 +1,286 @@
+from __future__ import annotations
+import subprocess
+import sys
+from dataclasses import dataclass, field
+from typing import Optional
+from rich.console import Console
+from rich.text import Text
+from render import Node, TreeApp, dump_text
+EMPTY_TREE = '4b825dc642cb6eb9a060e54bf8d69288fbee4904'
+
+class Git:
+
+    def __init__(self, cwd: str):
+        self.cwd = cwd
+        self._run('rev-parse', '--git-dir')
+
+    def _run(self, *args: str) -> str:
+        r = subprocess.run(['git', *args], cwd=self.cwd, capture_output=True, text=True)
+        if r.returncode != 0:
+            raise RuntimeError(f'git {' '.join(args)}: {r.stderr.strip()}')
+        return r.stdout
+
+    def current_branch(self) -> Optional[str]:
+        out = self._run('branch', '--show-current').strip()
+        return out or None
+
+    def branch_tips(self) -> dict[str, str]:
+        out = self._run('for-each-ref', '--format=%(refname:short)%09%(objectname)', 'refs/heads/')
+        return dict((line.split('\t') for line in out.splitlines() if line.strip()))
+
+    def load_commits(self) -> dict[str, 'Commit']:
+        out = self._run('log', '--branches', '--date=iso-strict', '--format=%H%x09%P%x09%an%x09%ad%x09%s%x09%b%x1e')
+        commits: dict[str, Commit] = {}
+        for rec in out.split('\x1e'):
+            rec = rec.strip('\n')
+            if not rec:
+                continue
+            sha, parents, author, date, subject, body = rec.lstrip('\n').split('\t', 5)
+            commits[sha] = Commit(sha, parents.split(), author, date, subject, body)
+        return commits
+
+    def diff(self, sha: str, parent: Optional[str]) -> str:
+        base = parent or EMPTY_TREE
+        return self._run('diff', '--no-color', base, sha)
+
+@dataclass
+class Commit:
+    sha: str
+    parents: list[str]
+    author: str
+    date: str
+    subject: str
+    body: str
+
+    @property
+    def short(self) -> str:
+        return self.sha[:7]
+
+@dataclass
+class Branch:
+    name: str
+    tip: str
+    parent: Optional[str] = None
+    fork_point: Optional[str] = None
+    merged: bool = False
+    own_commits: list[str] = field(default_factory=list)
+    grafted: list[str] = field(default_factory=list)
+    children: list[str] = field(default_factory=list)
+
+def first_parent_chain(commits: dict[str, Commit], tip: str) -> list[str]:
+    chain, cur, seen = ([], tip, set())
+    while cur and cur not in seen and (cur in commits):
+        seen.add(cur)
+        chain.append(cur)
+        parents = commits[cur].parents
+        cur = parents[0] if parents else None
+    return chain
+
+def pick_trunk(git: Git, tips: dict[str, str]) -> str:
+    current = git.current_branch()
+    if current and current in tips:
+        return current
+    for candidate in ('main', 'master'):
+        if candidate in tips:
+            return candidate
+    return sorted(tips)[0]
+
+def infer_hierarchy(commits: dict[str, Commit], tips: dict[str, str], trunk: str) -> dict[str, Branch]:
+    branches = {name: Branch(name=name, tip=tip) for name, tip in tips.items()}
+    chains = {name: first_parent_chain(commits, b.tip) for name, b in branches.items()}
+    index_in = {name: {sha: i for i, sha in enumerate(chain)} for name, chain in chains.items()}
+    trunk_owned = set(chains[trunk])
+    branches[trunk].own_commits = chains[trunk]
+    absorbs: dict[str, set[str]] = {name: set() for name in branches}
+    for name, chain in chains.items():
+        for sha in chain:
+            for p in commits[sha].parents[1:]:
+                for other, other_tip in tips.items():
+                    if other != name and p == other_tip:
+                        absorbs[name].add(other)
+    changed = True
+    while changed:
+        changed = False
+        for name, others in absorbs.items():
+            grown = others | {a for o in others for a in absorbs[o]}
+            if grown != others:
+                absorbs[name] = grown
+                changed = True
+    non_trunk_contenders: dict[str, list[str]] = {}
+    for name, chain in chains.items():
+        if name == trunk:
+            continue
+        for sha in chain:
+            non_trunk_contenders.setdefault(sha, []).append(name)
+
+    def owner_ignoring_trunk(sha: str) -> Optional[str]:
+        names = non_trunk_contenders[sha]
+        if len(names) == 1:
+            return names[0]
+        at_zero = [n for n in names if index_in[n][sha] == 0]
+        if len(at_zero) == 1:
+            return at_zero[0]
+        absorbing = [n for n in names if all((o == n or o in absorbs[n] for o in names))]
+        if absorbing:
+            return sorted(absorbing)[0]
+        min_index = min((index_in[n][sha] for n in names))
+        tied = [n for n in names if index_in[n][sha] == min_index]
+        return tied[0] if len(tied) == 1 else None
+
+    def owner(sha: str) -> Optional[str]:
+        return trunk if sha in trunk_owned else owner_ignoring_trunk(sha)
+    for name, binfo in branches.items():
+        if name == trunk:
+            continue
+        chain = chains[name]
+        boundary = next((i for i, sha in enumerate(chain) if owner(sha) not in (name, None)), len(chain))
+        boundary_ignoring_trunk = next((i for i, sha in enumerate(chain) if owner_ignoring_trunk(sha) != name), len(chain))
+        binfo.own_commits = chain[:boundary]
+        if boundary < len(chain):
+            binfo.fork_point = chain[boundary]
+            binfo.parent = owner(binfo.fork_point)
+        if boundary == 0 and boundary_ignoring_trunk > 0:
+            binfo.grafted = chain[:boundary_ignoring_trunk]
+    for name, binfo in branches.items():
+        if binfo.parent:
+            branches[binfo.parent].children.append(name)
+    owned_by: dict[str, str] = {sha: name for name, b in branches.items() for sha in b.own_commits}
+    for c in commits.values():
+        for p in c.parents[1:]:
+            owner_name = owned_by.get(p)
+            if owner_name:
+                branches[owner_name].merged = True
+    return branches
+
+def root_branches(branches: dict[str, Branch]) -> list[str]:
+    return sorted((name for name, b in branches.items() if b.parent is None))
+
+def merge_source_branch(c: Commit, branches: dict[str, Branch]) -> Optional[str]:
+    for p in c.parents[1:]:
+        for name, b in branches.items():
+            if p == b.tip or p in b.own_commits:
+                return name
+    return None
+
+def branch_detail(b: Branch, commits: dict[str, Commit]) -> Text:
+    t = Text()
+    t.append('Branch: ', style='bold cyan')
+    t.append(b.name + '\n\n', style='bold')
+    t.append('Tip:     ', style='dim')
+    t.append(f'{b.tip[:7]}  {commits[b.tip].subject}\n')
+    t.append('Parent:  ', style='dim')
+    t.append(f'{b.parent}\n' if b.parent else '(root -- no parent found)\n')
+    if b.fork_point:
+        t.append('Forked:  ', style='dim')
+        t.append(f'{b.fork_point[:7]}  {commits[b.fork_point].subject}\n')
+    t.append('Merged:  ', style='dim')
+    t.append('yes (real merge commit)\n' if b.merged else 'no\n')
+    if b.grafted:
+        t.append('Note:    ', style='dim')
+        t.append(f'{len(b.grafted)} commit(s) fast-forwarded into its parent, no merge commit\n')
+    t.append('Commits: ', style='dim')
+    t.append(f'{len(b.own_commits)} of its own\n')
+    return t
+
+def commit_detail(c: Commit, git: Git) -> Text:
+    t = Text()
+    t.append('Commit: ', style='bold yellow')
+    t.append(c.sha + '\n\n', style='bold')
+    t.append('Author: ', style='dim')
+    t.append(f'{c.author}  ({c.date})\n')
+    t.append('Parents: ', style='dim')
+    t.append(', '.join((p[:7] for p in c.parents)) or '(none -- root commit)')
+    t.append('\n\n')
+    t.append(c.subject + '\n', style='bold')
+    if c.body.strip():
+        t.append(c.body.strip() + '\n')
+    t.append('\n')
+    diff = git.diff(c.sha, c.parents[0] if c.parents else None)
+    for line in diff.splitlines():
+        style = 'green' if line.startswith('+') and (not line.startswith('+++')) else 'red' if line.startswith('-') and (not line.startswith('---')) else 'cyan' if line.startswith('@@') else 'white'
+        t.append(line + '\n', style=style)
+    return t
+
+def build_nodes(branches: dict[str, Branch], commits: dict[str, Commit], roots: list[str], current_branch: Optional[str], git: Git) -> list[Node]:
+
+    def commit_node(sha: str, children: list[Node]) -> Node:
+        c = commits[sha]
+        merge_from = merge_source_branch(c, branches) if len(c.parents) > 1 else None
+        label = Text()
+        label.append('● ', style='magenta' if merge_from else 'yellow')
+        label.append(c.short + '  ')
+        label.append(c.subject)
+        if merge_from:
+            label.append(f'  (⑂ {merge_from})', style='dim')
+        return Node(id=f'commit:{sha}', label=label, children=children, detail=lambda: commit_detail(c, git))
+
+    def graft_node(name: str) -> Node:
+        b = branches[name]
+        label = Text()
+        label.append('〇 ', style='dim cyan')
+        label.append(name, style='dim')
+        label.append('  (fast-forwarded, no merge commit)', style='dim italic')
+        children = [commit_node(sha, []) for sha in reversed(b.grafted)]
+        return Node(id=f'graft:{name}', label=label, children=children, detail=lambda: branch_detail(b, commits))
+
+    def branch_node(name: str) -> Node:
+        b = branches[name]
+        label = Text()
+        label.append('⑂ ', style='cyan')
+        label.append(name, style='bold' if name == current_branch else '')
+        if b.merged:
+            label.append(' *', style='yellow')
+        if name == current_branch:
+            label.append(' [HEAD]', style='bold green')
+        by_fork: dict[str, list[str]] = {}
+        grafts_by_tip: dict[str, str] = {}
+        for child in b.children:
+            cb = branches[child]
+            if cb.grafted:
+                grafts_by_tip[cb.grafted[0]] = child
+            else:
+                by_fork.setdefault(cb.fork_point, []).append(child)
+        children: list[Node] = []
+        commit_list = list(reversed(b.own_commits))
+        i, n = (0, len(commit_list))
+        while i < n:
+            sha = commit_list[i]
+            if sha in grafts_by_tip:
+                gname = grafts_by_tip[sha]
+                children.append(graft_node(gname))
+                i += len(branches[gname].grafted)
+                continue
+            kids = [branch_node(c) for c in by_fork.get(sha, [])]
+            children.append(commit_node(sha, kids))
+            i += 1
+        return Node(id=f'branch:{name}', label=label, children=children, detail=lambda: branch_detail(b, commits))
+    return [branch_node(name) for name in roots]
+
+def load_repo(path: str) -> tuple[Git, dict[str, Branch], dict[str, Commit], list[str], Optional[str]]:
+    git = Git(path)
+    tips = git.branch_tips()
+    commits = git.load_commits()
+    trunk = pick_trunk(git, tips)
+    branches = infer_hierarchy(commits, tips, trunk)
+    roots = root_branches(branches)
+    current = git.current_branch()
+    return (git, branches, commits, roots, current)
+
+def main() -> int:
+    args = sys.argv[1:]
+    dump = '--dump' in args
+    args = [a for a in args if a != '--dump']
+    path = args[0] if args else '.'
+    try:
+        git, branches, commits, roots, current = load_repo(path)
+    except RuntimeError as e:
+        print(f'Error: {e}', file=sys.stderr)
+        return 1
+    nodes = build_nodes(branches, commits, roots, current, git)
+    if dump:
+        Console().print(dump_text(nodes))
+        return 0
+    TreeApp(nodes, expanded={n.id for n in nodes}).run()
+    return 0
+if __name__ == '__main__':
+    sys.exit(main())

vgt-0.0.1a0/render.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Callable, Optional, Union
+from rich.text import Text
+from textual.app import App, ComposeResult
+from textual.containers import Horizontal, VerticalScroll
+from textual.widgets import Static
+from textual.reactive import reactive
+from textual.message import Message
+Detail = Union[str, Text, Callable[[], Union[str, Text]], None]
+
+@dataclass
+class Node:
+    id: str
+    label: Union[str, Text]
+    children: list['Node'] = field(default_factory=list)
+    detail: Detail = None
+
+@dataclass
+class FlatRow:
+    node: Node
+    depth: int
+    ancestor_last: list[bool]
+    is_last: bool
+
+def flatten(roots: list[Node], expanded: set[str]) -> list[FlatRow]:
+    rows: list[FlatRow] = []
+
+    def emit(node: Node, depth: int, ancestor_last: list[bool], is_last: bool) -> None:
+        rows.append(FlatRow(node, depth, list(ancestor_last), is_last))
+        if node.id not in expanded or not node.children:
+            return
+        child_ancestor = ancestor_last + [is_last]
+        for i, child in enumerate(node.children):
+            emit(child, depth + 1, child_ancestor, i == len(node.children) - 1)
+    for i, r in enumerate(roots):
+        emit(r, 0, [], i == len(roots) - 1)
+    return rows
+
+def render_row_line(row: FlatRow, is_cursor: bool=False, max_width: Optional[int]=None) -> Text:
+    text = Text()
+    for last in row.ancestor_last:
+        text.append('   ' if last else '│  ')
+    if row.depth > 0:
+        text.append('└─ ' if row.is_last else '├─ ')
+    text.append(row.node.label if isinstance(row.node.label, Text) else Text(row.node.label))
+    if max_width is not None and text.cell_len > max_width:
+        text.truncate(max_width, overflow='ellipsis')
+    if is_cursor:
+        text.stylize('reverse')
+    return text
+
+def all_ids(roots: list[Node]) -> set[str]:
+    ids: set[str] = set()
+
+    def walk(n: Node) -> None:
+        ids.add(n.id)
+        for c in n.children:
+            walk(c)
+    for r in roots:
+        walk(r)
+    return ids
+
+def dump_text(roots: list[Node], expanded: Optional[set[str]]=None) -> Text:
+    rows = flatten(roots, expanded if expanded is not None else all_ids(roots))
+    out = Text()
+    for row in rows:
+        out.append(render_row_line(row))
+        out.append('\n')
+    return out
+
+def _resolve(detail: Detail) -> Union[str, Text]:
+    value = detail() if callable(detail) else detail
+    return value if value is not None else ''
+
+class TreeWidget(Static):
+    can_focus = True
+    cursor_index: reactive[int] = reactive(0)
+    viewport_y: reactive[int] = reactive(0)
+
+    class CursorMoved(Message):
+
+        def __init__(self, node: Optional[Node]) -> None:
+            self.node = node
+            super().__init__()
+
+    def __init__(self, roots: list[Node], expanded: Optional[set[str]]=None, **kwargs):
+        super().__init__(**kwargs)
+        self.roots = roots
+        self.expanded: set[str] = expanded if expanded is not None else set()
+        self.rows: list[FlatRow] = []
+
+    def on_mount(self) -> None:
+        self.recompute()
+        self.focus()
+
+    def recompute(self) -> None:
+        prev_id = self.rows[self.cursor_index].node.id if self.rows and 0 <= self.cursor_index < len(self.rows) else None
+        self.rows = flatten(self.roots, self.expanded)
+        if prev_id is not None:
+            for i, r in enumerate(self.rows):
+                if r.node.id == prev_id:
+                    self.cursor_index = i
+                    break
+            else:
+                self.cursor_index = min(self.cursor_index, len(self.rows) - 1)
+        self._ensure_visible()
+        self.refresh()
+        self._emit_cursor()
+
+    def _emit_cursor(self) -> None:
+        self.post_message(self.CursorMoved(self.rows[self.cursor_index].node if self.rows else None))
+
+    def _ensure_visible(self) -> None:
+        height = max(self.size.height, 1)
+        if self.cursor_index < self.viewport_y:
+            self.viewport_y = self.cursor_index
+        elif self.cursor_index >= self.viewport_y + height:
+            self.viewport_y = self.cursor_index - height + 1
+
+    def render(self) -> Text:
+        if not self.rows:
+            return Text('(empty)', style='dim')
+        height = max(self.size.height, 1)
+        width = max(self.size.width, 1)
+        visible = self.rows[self.viewport_y:self.viewport_y + height]
+        lines = [render_row_line(r, is_cursor=self.viewport_y + i == self.cursor_index, max_width=width) for i, r in enumerate(visible)]
+        return Text('\n').join(lines)
+
+    def move(self, delta: int) -> None:
+        if not self.rows:
+            return
+        self.cursor_index = max(0, min(len(self.rows) - 1, self.cursor_index + delta))
+        self._ensure_visible()
+        self.refresh()
+        self._emit_cursor()
+
+    def collapse_or_up(self) -> None:
+        if not self.rows:
+            return
+        row = self.rows[self.cursor_index]
+        if row.node.children and row.node.id in self.expanded:
+            self.expanded.discard(row.node.id)
+            self.recompute()
+            return
+        target_depth = row.depth - 1
+        for i in range(self.cursor_index - 1, -1, -1):
+            if self.rows[i].depth == target_depth:
+                self.cursor_index = i
+                self._ensure_visible()
+                self.refresh()
+                self._emit_cursor()
+                return
+
+    def expand_row(self) -> None:
+        if not self.rows:
+            return
+        row = self.rows[self.cursor_index]
+        if row.node.children:
+            self.expanded.add(row.node.id)
+            self.recompute()
+
+class ContentWidget(VerticalScroll):
+
+    def compose(self) -> ComposeResult:
+        yield Static(id='content-text')
+
+    def show(self, node: Optional[Node]) -> None:
+        text = _resolve(node.detail) if node else '(nothing selected)'
+        if isinstance(text, str):
+            text = Text(text)
+        self.query_one('#content-text', Static).update(text)
+        self.scroll_home(animate=False)
+CSS = '\nScreen { layout: horizontal; }\n#tree { width: 2fr; height: 100%; border: solid $primary; padding: 0 1; }\n#content { width: 3fr; height: 100%; border: solid $accent; padding: 0 1; overflow-y: auto; }\n#content-text { width: 100%; height: auto; }\n'
+
+class TreeApp(App):
+    CSS = CSS
+    BINDINGS = [('j', 'move_down', 'Down'), ('k', 'move_up', 'Up'), ('h', 'collapse', 'Collapse/parent'), ('l', 'expand', 'Expand'), ('q', 'quit', 'Quit')]
+
+    def __init__(self, roots: list[Node], expanded: Optional[set[str]]=None):
+        super().__init__()
+        self.roots = roots
+        self.initial_expanded = expanded
+
+    def compose(self) -> ComposeResult:
+        with Horizontal():
+            yield TreeWidget(self.roots, self.initial_expanded, id='tree')
+            yield ContentWidget(id='content')
+
+    def on_tree_widget_cursor_moved(self, event: TreeWidget.CursorMoved) -> None:
+        self.query_one('#content', ContentWidget).show(event.node)
+
+    def action_move_down(self) -> None:
+        self.query_one('#tree', TreeWidget).move(1)
+
+    def action_move_up(self) -> None:
+        self.query_one('#tree', TreeWidget).move(-1)
+
+    def action_collapse(self) -> None:
+        self.query_one('#tree', TreeWidget).collapse_or_up()
+
+    def action_expand(self) -> None:
+        self.query_one('#tree', TreeWidget).expand_row()

vgt-0.0.1a0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

vgt-0.0.1a0/setup.py

@@ -0,0 +1,38 @@
+from setuptools import setup, find_packages
+from pathlib import Path
+
+long_description = (Path(__file__).parent / "README.md").read_text(encoding="utf-8")
+
+setup(
+    name="vgt",
+    url="https://www.mlx-code.com",
+    project_urls={
+        "Source": "https://github.com/JosefAlbers/mlx-code",
+        "Issues": "https://github.com/JosefAlbers/mlx-code/issues",
+        "Documentation": "https://www.mlx-code.com/",
+    },
+    author_email="albersj66@gmail.com",
+    author="J Joe",
+    license="Apache-2.0",
+    version="0.0.1a0",
+    readme="README.md",
+    description="TUI git viewer",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    python_requires=">=3.12.8",
+    install_requires=[
+        "textual>=8.2.7",
+        "rich>=15.0.0",
+    ],
+    extras_require={
+        "all": [
+        ],
+    },
+    # packages=find_packages(),
+    py_modules=["main", "render"],
+    entry_points={
+        "console_scripts": [
+            "vgt=main:main",
+        ]
+    },
+)

vgt-0.0.1a0/vgt.egg-info/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: vgt
+Version: 0.0.1a0
+Summary: TUI git viewer
+Home-page: https://www.mlx-code.com
+Author: J Joe
+Author-email: albersj66@gmail.com
+License: Apache-2.0
+Project-URL: Source, https://github.com/JosefAlbers/mlx-code
+Project-URL: Issues, https://github.com/JosefAlbers/mlx-code/issues
+Project-URL: Documentation, https://www.mlx-code.com/
+Requires-Python: >=3.12.8
+Description-Content-Type: text/markdown
+Requires-Dist: textual>=8.2.7
+Requires-Dist: rich>=15.0.0
+Provides-Extra: all
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+view git

vgt-0.0.1a0/vgt.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+main.py
+render.py
+setup.py
+vgt.egg-info/PKG-INFO
+vgt.egg-info/SOURCES.txt
+vgt.egg-info/dependency_links.txt
+vgt.egg-info/entry_points.txt
+vgt.egg-info/requires.txt
+vgt.egg-info/top_level.txt

vgt-0.0.1a0/vgt.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

vgt-0.0.1a0/vgt.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+vgt = main:main

vgt-0.0.1a0/vgt.egg-info/requires.txt

@@ -0,0 +1,4 @@
+textual>=8.2.7
+rich>=15.0.0
+
+[all]

vgt-0.0.1a0/vgt.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+main
+render