agent-lineup 0.1.0__py3-none-any.whl

agent_lineup-0.1.0.dist-info/METADATA

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: agent-lineup
+Version: 0.1.0
+Summary: See what your coding agent just changed, which edits are risky, and undo a file.
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+<p align="center"><img src="assets/lineup-logo.svg" alt="lineup logo" width="324"></p>
+
+# lineup
+
+`lineup` shows what your coding agent (Claude Code or Codex) just changed, flags the risky edits, and lets you undo a file.
+
+## Demo
+
+After the agent's reply, the hook prints a short line:
+
+```
+⚠ ≈ lineup: 2 HIGH
+  2 auth.py        auth or payment file changed
+  3 test_utils.py  assertion removed
+Undo: lineup rollback 2
+```
+
+`lineup risky` shows every changed file and the rule behind its score:
+
+```
+| ID | File          | Risk | Why (rule)                                  | Other           |
+| 1  | .env          | HIGH | .env or key file changed, contents not read | Can't roll back |
+| 2  | auth.py       | HIGH | auth or payment file changed                |                 |
+| 3  | test_utils.py | HIGH | assertion removed                           |                 |
+| 4  | utils.py      | LOW  | code edited, + function added: mul          |                 |
+```
+
+`lineup rollback 2` (or `lineup rollback auth.py`) puts the file back:
+
+```
+2   auth.py  restored
+Your versions from before this rollback are saved in .git/lineup/backups/2026-11-06_004042/.
+Also changed: .env (ID 1), test_utils.py (ID 3), utils.py (ID 4). Check whether they depend on this file.
+```
+
+## Install
+
+Needs Python 3.10 or newer, git, and [pipx](https://pipx.pypa.io).
+
+```
+pipx install git+https://github.com/HARSHAVARDHAN-RAJU5/agent-lineup
+cd your-repo
+lineup init --agent claude
+```
+
+Use `--agent codex` if you use Codex, or leave `--agent` out for both.
+
+`lineup init` shows the hooks it will add and asks before writing. Then start a new Claude Code session. In Codex, run `/hooks` and trust the lineup hooks.
+
+- No pipx: `python -m pip install --user pipx`, then `python -m pipx ensurepath`, then open a new terminal.
+- No git: the install fails with "Cannot find command 'git'". Install git first.
+- Upgrade: `pipx upgrade agent-lineup`. If it says it's already up to date, run `pipx install --force git+https://github.com/HARSHAVARDHAN-RAJU5/agent-lineup`.
+- Uninstall: run `lineup init --remove` in each repo first, then `pipx uninstall agent-lineup`. To delete lineup's saved data too, delete the `.git/lineup` folder in each repo.
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `lineup init` | Adds the hooks for Claude Code (`.claude/settings.local.json`) and Codex (`.codex/hooks.json`). `--agent claude` or `--agent codex` picks one. `--remove` takes them out again. |
+| `lineup diff` | What changed since the session started, with a short AI summary. |
+| `lineup risky` | Scores each changed file HIGH, MED or LOW using fixed rules, and shows the rule. |
+| `lineup rollback 3 4` | Undoes files by ID or name. Your current version is backed up first. |
+| `lineup report` | Usage counts to send as tester feedback. No code or file names. |
+
+## What gets sent to the AI
+
+Only `lineup diff` uses AI. It sends the changed lines to the agent you already have (Claude Code with Haiku, or Codex), with no tools. Nothing goes anywhere else, and lineup needs no API key.
+
+- `.env`, key and credential files are never sent. They're listed by name only.
+- Lockfile contents are left out. Secret-looking text is hidden before sending.
+- The hooks, `risky`, `rollback` and `report` use no AI. They run only on your machine.
+- lineup keeps its photo, file copies and backups in `.git/lineup/` in your repo. Private files are kept as fingerprints only, never copied.
+
+## Run it in a second terminal
+
+You can run lineup with `!` in the same session (for example `! lineup risky`), but the agent may comment on the output. Its commentary isn't part of lineup's check: the scores come from fixed rules, not from the agent.
+
+To avoid this, open a second terminal in the same folder and run lineup there.
+
+## Known limits
+
+- **Claude Code is tested. Codex hooks aren't fully tested yet**, and you must trust them with `/hooks` before they run.
+- The secret scan can miss things. Don't rely on it alone.
+- Tested on Windows. Mac and Linux aren't tested yet.
+- Rollback can't undo private files, files over 10 MB, links, or changes that are already committed.
+- Scores come from simple rules, so expect some false flags.
+
+## Develop
+
+```
+pip install -e ".[dev]"
+pytest
+```
+
+Testers: [docs/testers.md](https://github.com/HARSHAVARDHAN-RAJU5/agent-lineup/blob/main/docs/testers.md).

agent_lineup-0.1.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+agent_lineup-0.1.0.dist-info/licenses/LICENSE,sha256=9wRuZjooHxTu9-cZixscqDVmvWSSRrlURu2SROXQt64,1091
+lineup/__init__.py,sha256=u1fxKaH0tBg_6A3Y91fw4OzCPcnrKdyWCJTdjsiSuQE,109
+lineup/__main__.py,sha256=ZkCO9HQ-l25sXDLfGaKhrtjGaUbg_lxuPlPruGrqhTw,58
+lineup/banner.py,sha256=QarbGZLEqbrKyCg0GzOF9zi1rgE3vpPyoCCANbV_md4,2241
+lineup/changes.py,sha256=pOG6DAI0cA5ukThdLHLb3jQ3O_R8DEvu6_bD5127dnQ,16653
+lineup/cli.py,sha256=x_wqFl-81uzlK5faoDW3kuHzYjQ1yTO-ng10JQBNHSU,18639
+lineup/functions.py,sha256=JdU5UsVvo4p_2GEtngUoak4q0zPAmt_yS_-OP2Xu3Sc,4884
+lineup/git.py,sha256=MRhvjXGzwXK-NpLE2INu8HlzV1e9nzvFpjVAtnezVF0,5880
+lineup/guard.py,sha256=W_nC6SaFQBd4s0U99gVw0yVA6jOOy1Cx9qM6bWQ_giA,7418
+lineup/hookjson.py,sha256=AW1M31HQHWeVpH1fLMjNSwufMfyT9iZTsXysfAuzGts,2062
+lineup/hooks.py,sha256=JALQyKPrxDtrrPh9Q-gk8EaC5hF8K6daaKiOldw0LsQ,13411
+lineup/lineup-banner.txt,sha256=qays0dU83qnGGm5BdhTpfDZweELAbG3wW6RDh4ysbgM,708
+lineup/llm.py,sha256=lrcS3O8tFasFq2bWfHwLuaS3huQj7WeQHTGh85yAhpQ,5852
+lineup/paths.py,sha256=yHCD6NJfk7UlMKO3PX7S2VTFHOBXFqnM8T8_IE-WuwQ,2044
+lineup/rollback.py,sha256=V4Rhgmxl8f7u1uuu36LP2HwFTbSinM0LRbAHBS6_KVk,10238
+lineup/rules.py,sha256=oElNVDgYEKHK5qgyyEYt6B8GZI1KSYe2ycCeXq9UuSY,9420
+lineup/snapshot.py,sha256=KtVOj6VepfhhTP9iUmnu7r6hQyjrXtzJ2nT7OFqmm_8,7257
+lineup/store.py,sha256=Ita6eCk6y6O-5z2SuzFcVttusIBQdvoYcpzVpYySiaY,7385
+lineup/summary.py,sha256=CgYbyelm9qbLW2_mxWJ4MuP1joqD-weEmKr8NBDrhoo,2651
+lineup/table.py,sha256=XHtCG4HQpyNj5HLPhP87US2D9VqcdlXP3Nk_m3Repyw,2236
+agent_lineup-0.1.0.dist-info/METADATA,sha256=r0nd429mG28JfPeypVraeRwsNeC-XSoCZAAazmJ6Wlo,4805
+agent_lineup-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+agent_lineup-0.1.0.dist-info/entry_points.txt,sha256=4kUTJxSAL5faNMua1h-N4gO5XlLg5fnw7fYAXqCg0jA,43
+agent_lineup-0.1.0.dist-info/top_level.txt,sha256=6vFg2PzbsMrFEZHnUq1mv4jRZGnOFHc6Vf1pBfzxWm0,7
+agent_lineup-0.1.0.dist-info/RECORD,,

agent_lineup-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

agent_lineup-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lineup = lineup.cli:main

agent_lineup-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Harshavardhan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agent_lineup-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+lineup

lineup/__init__.py

@@ -0,0 +1,3 @@
+"""lineup: see what your coding agent just changed, flag risky edits, undo a file."""
+
+__version__ = "0.1.0"

lineup/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from lineup.cli import main
+
+sys.exit(main())

lineup/banner.py

@@ -0,0 +1,70 @@
+"""The lineup banner, for the user's own terminal only (init, --version, no command).
+
+Never printed by hooks, diff, risky or rollback, so nothing the agent reads ever contains it.
+"""
+
+import os
+import sys
+from importlib import resources
+
+BLUE = "\x1b[38;2;111;140;216m"  # #6F8CD8, readable on dark terminals
+BLUE_256 = "\x1b[38;5;68m"  # nearest 256-colour shade, for terminals without 24-bit colour
+RESET = "\x1b[0m"
+
+
+def text():
+    return resources.files("lineup").joinpath("lineup-banner.txt").read_text(encoding="utf-8")
+
+
+def _windows_colour_on(stream):
+    """Turn on colour codes in a Windows console. False if it can't be done."""
+    try:
+        import ctypes
+        import msvcrt
+        handle = msvcrt.get_osfhandle(stream.fileno())
+        kernel32 = ctypes.windll.kernel32
+        mode = ctypes.c_uint32()
+        if not kernel32.GetConsoleMode(handle, ctypes.byref(mode)):
+            return False
+        return bool(mode.value & 0x0004 or kernel32.SetConsoleMode(handle, mode.value | 0x0004))
+    except (AttributeError, OSError, ValueError, ImportError):
+        return False
+
+
+def colour(stream):
+    """The colour code to use, or "" for plain text."""
+    if "NO_COLOR" in os.environ or os.environ.get("TERM") == "dumb":
+        return ""
+    if not is_terminal(stream):
+        return ""
+    if sys.platform == "win32":
+        return BLUE if _windows_colour_on(stream) else ""
+    if os.environ.get("COLORTERM", "").lower() in ("truecolor", "24bit"):
+        return BLUE
+    return BLUE_256
+
+
+def is_terminal(stream):
+    try:
+        return stream.isatty()
+    except (AttributeError, ValueError):
+        return False
+
+
+def show(stream=None):
+    """Print the banner, only to a real terminal (piped or redirected output gets none)."""
+    stream = stream or sys.stdout
+    if not is_terminal(stream):
+        return
+    banner = text()
+    code = colour(stream)
+    if code:
+        banner = code + banner.rstrip("\n") + RESET + "\n"
+    try:
+        stream.write(banner)
+    except UnicodeEncodeError:  # e.g. piped output on Windows: send the exact UTF-8 bytes
+        stream.flush()
+        stream.buffer.write(banner.encode("utf-8"))
+        stream.buffer.flush()
+    stream.write("\n")
+    stream.flush()

lineup/changes.py

@@ -0,0 +1,403 @@
+"""Finds what changed in the repo and sorts it into Additions, Removals, Edits and Schema."""
+
+import difflib
+import hashlib
+import os
+import posixpath
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from lineup import functions, git, hookjson, paths, store, table
+from lineup.guard import is_private, private_pathspecs
+
+BIG_FILE_BYTES = 10 * 1024 * 1024
+
+LOCKFILES = {
+    "package-lock.json", "yarn.lock", "pnpm-lock.yaml", "poetry.lock", "pipfile.lock",
+    "cargo.lock", "go.sum", "composer.lock", "gemfile.lock", "uv.lock", "bun.lockb",
+}
+
+
+@dataclass
+class Change:
+    path: str
+    kind: str  # "added", "deleted" or "modified"
+    file_kind: str = "code"
+    private: bool = False
+    big: bool = False
+    binary: bool = False
+    symlink: bool = False  # never followed: only where it points is compared
+    copy_of_private: bool = False  # same bytes as a private file (e.g. .env renamed to settings.txt)
+    lineup_hooks_only: bool = False  # an agent settings file where only lineup's own hooks changed
+    lines_added: int = 0
+    lines_removed: int = 0
+    diff: str = ""  # never filled for private, big, binary or symlink files
+    funcs_added: list = field(default_factory=list)
+    funcs_removed: list = field(default_factory=list)
+    deps_added: list = field(default_factory=list)
+
+
+# ---- what kind of file is this (by path only) ----
+
+_TEST_DIRS = {"test", "tests", "__tests__", "spec", "specs"}
+_TEST_NAME = re.compile(r"(^test_.*\.py$|_test\.(py|go)$|\.(test|spec)\.[jt]sx?$|^conftest\.py$)")
+_SCHEMA = re.compile(r"(^|/)(migrations?|alembic)/|\.sql$|(^|/)schema\.(prisma|rb|sql)$|(^|/)db/schema")
+_DOCS = re.compile(r"\.(md|rst|adoc)$|^docs?/|(^|/)(readme|changelog|license)(\.\w+)?$", re.I)
+_CONFIG = re.compile(r"\.(ya?ml|toml|ini|cfg|conf)$|(^|/)dockerfile|(^|/)docker-compose|(^|/)\.github/|(^|/)\.claude/", re.I)
+_AUTH_WORDS = {
+    "auth", "authn", "authz", "authenticate", "authentication", "authorize", "authorization", "oauth",
+    "login", "logins", "session", "sessions", "password", "passwords",
+    "payment", "payments", "billing", "checkout", "checkouts",
+}
+# Words in a path: split at / _ - . digits and capitals. "src/AuthService.ts" -> src, Auth, Service, ts
+_WORD = re.compile(r"[A-Z]+(?![a-z])|[A-Z]?[a-z]+")
+
+
+def path_words(path):
+    return {word.lower() for word in _WORD.findall(path)}
+
+
+def is_auth(path):
+    """Whole words only: auth_service.py and AuthService.ts match, author.py and authority.py don't."""
+    return bool(path_words(path) & _AUTH_WORDS)
+
+
+def file_kind(path):
+    """One word describing the file: private, test, schema, lockfile, dependencies, config, docs, auth or code."""
+    name = posixpath.basename(path).lower()
+    parts = set(path.lower().split("/")[:-1])
+    if is_private(path):
+        return "private"
+    if parts & _TEST_DIRS or _TEST_NAME.search(name):
+        return "test"
+    if _SCHEMA.search(path.lower()):
+        return "schema"
+    if name in LOCKFILES:
+        return "lockfile"
+    if functions.is_dependency_file(path):
+        return "dependencies"
+    if _CONFIG.search(path):
+        return "config"
+    if _DOCS.search(path):
+        return "docs"
+    if is_auth(path):
+        return "auth"
+    return "code"
+
+
+# ---- reading both versions ----
+
+def _is_binary(data):
+    return b"\0" in data[:8192]
+
+
+def _decode(data):
+    return data.decode("utf-8", "replace") if data is not None else ""
+
+
+def fingerprint(file):
+    """SHA-256 of a file: changes if the file changes, but can't be turned back into it."""
+    digest = hashlib.sha256()
+    with open(file, "rb") as f:
+        for chunk in iter(lambda: f.read(1 << 20), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def is_link(file):
+    """True for a symlink or a Windows junction (a shortcut). Checked without opening it."""
+    return paths.is_link(file)
+
+
+def read_link(file):
+    """Where a link points, as bytes. Reads the link itself, never the file it points to."""
+    return os.fsencode(os.readlink(file))
+
+
+def link_hash(file):
+    """Fingerprint of where a link points (never of what it points to)."""
+    return hashlib.sha256(read_link(file)).hexdigest()
+
+
+def _link_change(root, base, row, path, file):
+    """A path that is a symlink now: compare only where it points. Never opens the target."""
+    target = read_link(file)
+    at_start = (row or {}).get("at_start")
+    if at_start == "symlink":
+        if hashlib.sha256(target).hexdigest() == row.get("link"):
+            return None
+        kind = "modified"
+    elif at_start == "missing":
+        kind = "added"
+    elif at_start:
+        kind = "modified"
+    else:
+        old = git.show_file(root, (row or {}).get("base", base), path)  # git stores a link as its target
+        if old == target:
+            return None
+        kind = "added" if old is None else "modified"
+    private = is_private(path)
+    return Change(path=path, kind=kind, file_kind="private" if private else file_kind(path),
+                  private=private, symlink=True)
+
+
+def _build(root, path, kind, old_size, load_old, new_size=None, load_new=None):
+    """Compare the before and after of one file. Returns None if nothing really changed.
+
+    The "after" is the file on disk, unless `new_size` and `load_new` give another version.
+    """
+    change = Change(path=path, kind=kind, file_kind=file_kind(path))
+    if change.file_kind == "private":
+        change.private = True
+        return change  # never read a private file
+    file = Path(root, path)
+    if new_size is None:
+        if kind != "deleted" and is_link(file):
+            change.symlink = True
+            return change  # never follow a link
+        new_size = file.stat().st_size if kind != "deleted" else 0
+        load_new = file.read_bytes
+    if max(old_size, new_size) > BIG_FILE_BYTES:
+        change.big = True
+        return change
+
+    old = (load_old() or b"") if kind != "added" else b""
+    new = (load_new() or b"") if kind != "deleted" else b""
+    if kind == "modified" and old == new:
+        return None
+    if _is_binary(old) or _is_binary(new):
+        change.binary = True
+        return change
+
+    old_text, new_text = _decode(old), _decode(new)
+    old_lines, new_lines = old_text.splitlines(), new_text.splitlines()
+    diff = list(difflib.unified_diff(old_lines, new_lines, f"a/{path}", f"b/{path}", lineterm=""))
+    if kind == "modified" and not diff:
+        return None  # e.g. only line endings differ
+    body = diff[2:]  # skip the ---/+++ header
+    change.lines_added = sum(1 for line in body if line.startswith("+"))
+    change.lines_removed = sum(1 for line in body if line.startswith("-"))
+    change.diff = "\n".join(diff)
+    if path in hookjson.SETTINGS_FILES:
+        change.lineup_hooks_only = hookjson.only_lineup_changed(old_text, new_text)
+    change.funcs_added, change.funcs_removed = functions.function_changes(path, old_text, new_text)
+    change.deps_added = functions.new_dependencies(path, old_text, new_text)
+    return change
+
+
+SECRET_COPY_MAX_BYTES = 1024 * 1024  # private files are small; don't fingerprint big files for this
+
+
+def private_fingerprints(root, rows=None, changed=()):
+    """Fingerprints of every private file we know: from the photo, and private files on disk now."""
+    hashes = {r["hash"] for r in (rows or {}).values() if r.get("at_start") == "private" and r.get("hash")}
+    names = {p for p in changed if is_private(p)}
+    names.update(p for p in git.ignored_files(root, private_pathspecs()) if is_private(p))
+    names.update(p for p in git.tracked_files(root, private_pathspecs()) if is_private(p))
+    for name in names:
+        file = Path(root, name)
+        if paths.unsafe(root, name):
+            continue  # never follow a link, even inside the repo
+        if not is_link(file) and file.is_file() and file.stat().st_size > 0:
+            hashes.add(fingerprint(file))
+    return hashes
+
+
+def is_copy_of_private(file, hashes):
+    """True if `file` has exactly the same bytes as a private file. Hashes it; never reads it as text."""
+    if not hashes or is_private(Path(file).name) or is_link(file) or not file.is_file():
+        return False  # a private name is just private, not a "copy"
+    size = file.stat().st_size
+    return 0 < size <= SECRET_COPY_MAX_BYTES and fingerprint(file) in hashes
+
+
+def seen_fingerprint(root, path):
+    """What lineup saw of a changed file at a check: its fingerprint, "deleted", or None if not fingerprinted
+    (private, behind a link, outside the repo, or big)."""
+    file = Path(root, path)
+    if paths.unsafe(root, path) or is_private(path) or is_link(file):
+        return None
+    if not os.path.lexists(file):
+        return "deleted"
+    if not file.is_file() or file.stat().st_size > BIG_FILE_BYTES:
+        return None
+    return fingerprint(file)
+
+
+def _private_copy(path, kind):
+    return Change(path=path, kind=kind, file_kind="private", private=True, copy_of_private=True)
+
+
+def _kind(existed, exists_now):
+    if not existed:
+        return "added" if exists_now else None
+    return "modified" if exists_now else "deleted"
+
+
+def _compare(root, base, row, path, secret_hashes=frozenset()):
+    """Find the "before" of one file (photo first, then git) and compare it with now.
+
+    A file with the same bytes as a private file (`secret_hashes`) is treated as private and never read.
+    """
+    file = Path(root, path)
+    reason = paths.unsafe(root, path)
+    if reason == paths.OUTSIDE:
+        return None  # never read anything outside the repo
+    if reason and paths.link_in_folders(root, path):  # e.g. a folder replaced by a junction
+        at_start = (row or {}).get("at_start")
+        existed = at_start not in (None, "missing") or git.blob_size(root, (row or {}).get("base", base), path) is not None
+        kind = _kind(existed, os.path.lexists(file)) or "modified"
+        return Change(path=path, kind=kind, file_kind="private" if is_private(path) else file_kind(path),
+                      private=is_private(path), symlink=True)
+    if is_link(file):
+        return _link_change(root, base, row, path, file)
+    exists_now = file.is_file()
+    at_start = (row or {}).get("at_start")
+
+    if at_start == "symlink":  # was a link in the photo: nothing of it was read, so name only
+        return Change(path=path, kind=_kind(True, exists_now), file_kind=file_kind(path),
+                      private=is_private(path), symlink=True)
+
+    if at_start == "private":  # only a fingerprint in the photo
+        if exists_now and fingerprint(file) == row["hash"]:
+            return None
+        return Change(path=path, kind=_kind(True, exists_now), file_kind="private", private=True)
+
+    if at_start == "big":  # only size and time in the photo
+        if exists_now:
+            stat = file.stat()
+            if stat.st_size == row.get("size") and stat.st_mtime_ns == row.get("mtime_ns"):
+                return None
+        return Change(path=path, kind=_kind(True, exists_now), file_kind=file_kind(path), big=True)
+
+    if at_start == "uncommitted":  # a saved copy in the photo
+        data = store.read_copy(root, path) or b""
+        kind = _kind(True, exists_now)
+        if kind != "deleted" and is_copy_of_private(file, secret_hashes):
+            return _private_copy(path, kind)
+        return _build(root, path, kind, len(data), lambda: data)
+
+    if at_start == "missing":  # already gone when the photo was taken
+        kind = _kind(False, exists_now)
+        if kind and is_copy_of_private(file, secret_hashes):
+            return _private_copy(path, kind)
+        return _build(root, path, kind, 0, lambda: b"") if kind else None
+
+    rev = (row or {}).get("base", base)  # not in the photo: git has the "before"
+    old_size = git.blob_size(root, rev, path)
+    kind = _kind(old_size is not None, exists_now)
+    if not kind:
+        return None
+    if kind != "deleted" and is_copy_of_private(file, secret_hashes):
+        before = git.show_file(root, rev, path) if kind == "modified" else None
+        if before is not None and hashlib.sha256(before).hexdigest() == fingerprint(file):
+            return None  # unchanged since the photo (only hashed, never read as text)
+        return _private_copy(path, kind)
+    return _build(root, path, kind, old_size or 0, lambda: git.show_file(root, rev, path))
+
+
+def committed_changes(root, old, new):
+    """Files changed by the commits between `old` and `new`, each compared with its version at `old`."""
+    found = []
+    for path in git.files_between(root, old, new):
+        old_size, new_size = git.blob_size(root, old, path), git.blob_size(root, new, path)
+        kind = _kind(old_size is not None, new_size is not None)
+        if not kind:
+            continue
+        change = _build(root, path, kind, old_size or 0, lambda p=path: git.show_file(root, old, p),
+                        new_size or 0, lambda p=path: git.show_file(root, new, p))
+        if change:
+            found.append(change)
+    return found
+
+
+def find_changes(root, table=None):
+    """Every file that changed since the photo (`table`), or since the last commit if there's no photo."""
+    if table:
+        base, rows = table["start_commit"], table["files"]
+    else:
+        base, rows = git.head_commit(root) or git.EMPTY_TREE, {}
+
+    paths = {path for _, path in git.changed_files(root, base)}
+    paths.update(git.untracked_files(root))
+    paths.update(rows)
+    if table:  # a hidden private file created after the photo
+        paths.update(p for p in git.ignored_files(root, private_pathspecs()) if is_private(p))
+
+    secret_hashes = private_fingerprints(root, rows, paths)
+    found = []
+    for path in sorted(paths):
+        change = _compare(root, base, rows.get(path), path, secret_hashes)
+        if change:
+            found.append(change)
+    return found
+
+
+# ---- sorting into groups ----
+
+def _what(change):
+    if change.symlink:
+        return "link, not followed"
+    if change.private:
+        return "private, contents not read"
+    if change.big:
+        return "big file, not read"
+    if change.binary:
+        return "binary file"
+    return f"+{change.lines_added} -{change.lines_removed}"
+
+
+def sort_into_groups(changes):
+    """Group changes for display: {group: [(name, description, file path)]}."""
+    from lineup.rules import assertions_removed  # here: rules is only needed for display
+
+    groups = {"Additions": [], "Removals": [], "Edits": [], "Schema": []}
+    for c in changes:
+        def add(title, name, what, path=c.path):
+            groups[title].append((name, what, path))
+
+        test = c.file_kind == "test"
+        not_read = c.private or c.big or c.binary or c.symlink
+        if c.kind == "added":
+            what = "new test file" if test else "new file"
+            add("Additions", c.path, f"{what}, {_what(c)}" if not_read else what)
+        elif c.kind == "deleted":
+            what = "test file deleted" if test else "file deleted"
+            add("Removals", c.path, f"{what}, {_what(c)}" if not_read else what)
+        else:
+            add("Edits", c.path, _what(c) if c.file_kind in ("code", "private") else f"{c.file_kind}, {_what(c)}")
+
+        if c.kind != "deleted":
+            for name in c.funcs_added:
+                label = "test added" if test else "function added"
+                add("Additions", name, f"{label} ({c.path})")
+            for dep in c.deps_added:
+                add("Additions", dep, f"new package ({c.path})")
+        if c.kind != "added":
+            for name in c.funcs_removed:
+                label = "test removed" if test else "function removed"
+                add("Removals", name, f"{label} ({c.path})")
+        lost = assertions_removed(c)
+        if lost:
+            add("Removals", "assertion" if lost == 1 else "assertions", f"{lost} removed ({c.path})")
+
+        if c.file_kind == "schema":
+            add("Schema", c.path, c.kind)
+    return groups
+
+
+def format_groups(groups, base_label, box=None, ids=None):
+    """The groups as one table: Group | ID | Name | What, with a line between groups.
+
+    `ids` is {path: ID} (the same IDs as lineup risky); rows about a function, package or assertion
+    show the ID of the file they're in.
+    """
+    ids = ids or {}
+    blocks = []
+    for title, items in groups.items():
+        rows = items or [("nothing", "", None)]
+        blocks.append([(title if i == 0 else "", "" if path is None else ids.get(path, "-"), name, what)
+                       for i, (name, what, path) in enumerate(rows)])
+    body = table.draw(("Group", "ID", "Name", "What"), blocks, (9, 4, 40, 50), box)
+    return f"lineup diff (compared with {base_label})\n\n{body}"