agent-lineup 0.1.0__py3-none-any.whl

lineup/cli.py

@@ -0,0 +1,440 @@
+"""Command-line entry point: `lineup <command>`."""
+
+import argparse
+import sys
+import textwrap
+
+from lineup import __version__, banner, changes, git, guard, hooks, llm, rollback, rules, snapshot, store, summary
+from lineup import table as tables
+
+
+def _root():
+    try:
+        return git.repo_root()
+    except git.GitError as e:
+        print(f"lineup: {e}", file=sys.stderr)
+        return None
+
+
+def _commit_label(commit):
+    return "no commits yet" if commit == git.EMPTY_TREE else commit[:7]
+
+
+def _hook(args):
+    if args.event != "start" or (args.agent and not args.fresh):  # called by Claude Code / Codex
+        return hooks.run_hook(args.event, args.agent)
+    root = _root()
+    if root is None:
+        return 2
+    table, kept = snapshot.start_session(root, fresh=args.fresh, agent=args.agent)
+    if kept:
+        word = "file" if kept == 1 else "files"
+        print(f"Keeping the earlier snapshot: {kept} uncommitted {word} from before this session. "
+              "Some may be your own edits. Commit them, or run lineup hook start --fresh to start over.")
+    else:
+        print(f"lineup: photo taken at {_commit_label(table['start_commit'])} ({snapshot.summary(table)})")
+    return 0
+
+
+def _collect(root):
+    """Shared by diff and risky: flag new commits, find changes, give IDs.
+
+    Returns (table, found, committed, label). `committed` are files in new commits.
+    """
+    if store.has_snapshot(root):
+        table = store.load_table(root)
+        committed = snapshot.check_commits(root, table)
+        found = changes.find_changes(root, table)
+        snapshot.record_check(root, table, found)
+        label = f"photo taken {table['taken_at']} at {_commit_label(table['start_commit'])}"
+        return table, found, committed, label
+    found = changes.find_changes(root)
+    head = git.head_commit(root)
+    return None, found, [], f"last commit {head[:7]}" if head else "an empty repo (no commits yet)"
+
+
+def _no_photo(root):
+    """No photo yet: take one now so the next check is exact."""
+    snapshot.take(root)
+    print("\nNo snapshot from the session start. These changes may include your own edits, "
+          "and they can't be rolled back. Tracking from now on.")
+
+
+def scores(root, found):
+    """{path: "HIGH" | "MED" | "LOW"} from the rules (the same scores `risky` shows)."""
+    return {c.path: rules.score(rules.rules_for(c, found, root)) for c in found}
+
+
+def _ai_summary(root, table, found):
+    """The AI part of `diff`: Summary text plus one line per file. Never stops `diff` from printing."""
+    levels = scores(root, found)
+    items, skipped = guard.ai_input(found, levels)
+    agent = llm.pick_agent(table)
+    if agent is None:
+        return "Summary unavailable: no agent found.\n\n"
+    is_installed = bool(llm.installed(llm.AGENTS[agent][0]))
+
+    def say_asking():
+        if is_installed:  # no "Asking" line for an agent that can't be asked
+            print(f"Asking {agent} for a summary...", file=sys.stderr, flush=True)
+
+    result = summary.summarize(root, items, agent, on_ask=say_asking)
+    notes = {path: note for path, _, note, _ in items if note}
+    ids = {p: r["id"] for p, r in (table or {}).get("files", {}).items() if "id" in r}
+    cut = [path for path, _, _, diff in items if diff.endswith(guard.CUT_MARK)]
+    rows = []
+    for path in sorted(levels, key=lambda p: (-rules.LEVELS[levels[p]], p)):
+        if result["files"].get(path):
+            line = result["files"][path] + (" (diff cut)" if path in cut else "")
+        elif path in skipped:
+            line = f"not summarized ({levels[path]}, diff too big)"
+        elif path in notes:
+            line = notes[path][:1].upper() + notes[path][1:]
+        else:
+            line = "no summary yet"
+        rows.append((ids.get(path, "-"), path, levels[path], line))
+
+    out = []
+    if result["overview"]:
+        text = textwrap.fill(result["overview"], 78, initial_indent="  ", subsequent_indent="  ")
+        out.append(f"Summary (AI guess, by {agent})\n{text}\n")
+    else:
+        out.append(f"Summary unavailable: {result['reason'] or 'no answer'}.\n")
+    out.append(tables.draw(("ID", "File", "Risk", "What changed (AI guess)"), [rows], (4, 40, 4, 50)).rstrip("\n"))
+    limits = []
+    if cut:
+        limits.append(f"Not fully summarized: {', '.join(cut)} (diff cut, too long).")
+    if skipped:
+        limits.append(f"Not sent: {', '.join(skipped)} (over the {guard.AI_LINE_LIMIT:,}-line limit).")
+    if limits:
+        out.append(" ".join(limits))
+    return "\n".join(out) + "\n\n"
+
+
+def _diff(args):
+    root = _root()
+    if root is None:
+        return 2
+    table, found, committed, label = _collect(root)
+    store.count_usage(root, diff_runs=1)
+    if committed:
+        names = ", ".join(f"{c.path} ({c.file_kind})" for c in committed)
+        print(f"Committed since last check: {names}\n")
+    if found:
+        try:
+            ai = _ai_summary(root, table, found)
+        except Exception:  # the AI part must never stop diff from printing
+            ai = "Summary unavailable: unexpected error.\n\n"
+        ids = {p: r["id"] for p, r in (table or {}).get("files", {}).items() if "id" in r}
+        groups = changes.format_groups(changes.sort_into_groups(found), label, ids=ids)
+        title, _, body = groups.partition("\n\n")
+        print(f"{title}\n\n{ai}{body}", end="")
+    else:
+        print(_no_changes("diff", root, table))
+    _print_staged(root, found)
+    if table is None:
+        _no_photo(root)
+    return 0
+
+
+def _other(change):
+    notes = []
+    if change.kind == "added":
+        notes.append("New")
+    if change.kind == "deleted":
+        notes.append("Deleted")
+    if change.private or change.big:
+        notes.append("Can't roll back")
+    return ", ".join(notes)
+
+
+def _why(reasons):
+    return "\n".join(reason if i == 0 else f"+ {reason}" for i, reason in enumerate(reasons))
+
+
+def risky_rows(root, table, found):
+    """[(id, path, level, why, other)], HIGH first, then by ID."""
+    rows = []
+    for change in found:
+        flags = sorted(rules.rules_for(change, found, root), key=lambda f: -rules.LEVELS[f[0]])
+        row_id = table["files"][change.path]["id"] if table else "-"
+        rows.append((row_id, change.path, rules.score(flags), _why([r for _, r in flags]), _other(change)))
+    rows.sort(key=lambda r: (-rules.LEVELS[r[2]], r[0] if isinstance(r[0], int) else 0, r[1]))
+    return rows
+
+
+def committed_rows(table):
+    """Saved scores of files in commits since the photo: [(commit, path, level, why)], HIGH first."""
+    saved = (table or {}).get("committed", [])
+    rows = [(c["commit"][:7], c["path"], c["risk"], _why(c["reasons"])) for c in saved]
+    return sorted(rows, key=lambda r: -rules.LEVELS[r[2]])  # stable: same level keeps commit order
+
+
+def _risky(args):
+    root = _root()
+    if root is None:
+        return 2
+    table, found, _, label = _collect(root)
+    store.count_usage(root, risky_runs=1)
+    committed = committed_rows(table)
+    if not found and not committed:
+        print(_no_changes("risky", root, table))
+    else:
+        print(f"lineup risky (compared with {label})\n")
+    if found:
+        rows = risky_rows(root, table, found)
+        print(tables.draw(("ID", "File", "Risk", "Why (rule)", "Other"), [[r] for r in rows], (4, 40, 4, 50, 20)), end="")
+    elif committed:
+        print("No uncommitted changes since the photo.")
+    if committed:
+        print("\nCommitted (lineup can't roll these back; use git to undo them)\n")
+        print(tables.draw(("Commit", "File", "Risk", "Why (rule)"), [[r] for r in committed], (7, 40, 4, 50)), end="")
+    _print_staged(root, found or committed)
+    if table is None:
+        _no_photo(root)
+    return 0
+
+
+def _no_changes(command, root, table):
+    since = "photo" if table else "last commit"
+    if git.staged_differs(root):  # never say "no changes" while a staged copy still differs
+        return f"lineup {command}: no changes in your files since the {since}, but a staged copy still has a change:"
+    return f"lineup {command}: no changes since the {since}"
+
+
+def _print_staged(root, shown_something):
+    lines = staged_note(root)
+    if lines:
+        print(("\n" if shown_something else "") + "\n".join(lines))
+
+
+def staged_note(root, only=None):
+    """Warning lines for files whose staged copy still differs from the file on disk."""
+    staged = sorted(p for p in git.staged_differs(root) if only is None or p in only)
+    return [f"The staged copy of {p} still has the old change. Run git restore --staged {p} before committing."
+            for p in staged]
+
+
+def _rollback(args):
+    root = _root()
+    if root is None:
+        return 2
+    if not store.has_snapshot(root):
+        print("No snapshot from the session start, so rollback could wipe your own work. Nothing was changed.")
+        return 1
+    last_check = store.load_table(root)  # before refreshing: to spot files changed since the last check
+    table, _, _, _ = _collect(root)  # new commits first, so committed files are refused
+    resolved, problems_found = [], []
+    for token in args.ids:  # IDs or file names
+        file_id, problem = rollback.resolve(table, token)
+        if problem:
+            problems_found.append(problem)
+        else:
+            resolved.append(file_id)
+    ids = list(dict.fromkeys(resolved))  # "3 3" (or "3 auth.py") counts once
+    unknown = [i for i in ids if i not in rollback.valid_ids(table)]
+    if problems_found or unknown:  # a typo or an unclear name: change nothing
+        valid = ", ".join(str(i) for i in rollback.valid_ids(table)) or "none yet (run lineup risky first)"
+        lines = [f"{problem[:1].upper()}{problem[1:]}." for problem in problems_found]
+        if unknown:
+            lines.append(f"No file with ID {', '.join(str(i) for i in unknown)}.")
+        print(" ".join(lines) + f" Valid IDs: {valid}. Nothing was changed.")
+        return 1
+
+    undos = [rollback.plan_undo(root, table, i, last_check) for i in ids]
+    run = rollback.new_backup_run(root)
+    width = max(len(u.path) for u in undos)
+    print("lineup rollback\n")
+    problems = False
+    for undo in undos:
+        word = rollback.apply_undo(root, undo, run)
+        if undo.action == "refuse":
+            problems = True
+            word = f"skipped: {undo.reason}"
+        elif undo.action == "nothing":
+            word = f"nothing to do: {undo.reason}"
+        elif word.startswith("failed"):
+            problems = True
+        outcome = ("refused" if undo.action == "refuse" else "nothing_to_do" if undo.action == "nothing"
+                   else "failed" if word.startswith("failed") else "done")
+        store.count_usage(root, **{f"rollback_{outcome}": 1})
+        print(f"{undo.id:<3} {undo.path:<{width}}  {word}")
+        if undo.action in rollback.DONE and not word.startswith("failed"):
+            for warning in undo.warnings:
+                print(f"{'':<3} {'':<{width}}  Warning: {warning}")
+    done = [u.path for u in undos if u.action in rollback.DONE]
+    if done:
+        store.add_rollback_note(root, done)  # the agent is told on its next turn (phase 7 hooks)
+    if store.backup_run_exists(root, run):
+        print(f"\nYour versions from before this rollback are saved in .git/lineup/backups/{run}/.")
+    staged = staged_note(root, set(done))
+    if staged:
+        print("\n" + "\n".join(staged))
+    if done:
+        notes = rollback.other_files_notes(root, table, done, set(ids))
+        if notes:
+            print("\n" + "\n".join(notes))
+        if hooks.installed(root):
+            print("\nThe agent will be told on your next message that these files were rolled back.")
+    return 1 if problems else 0
+
+
+def report_text(usage):
+    """The usage summary for testers to send: counts and dates only, from a fixed list of names."""
+    c, days = usage["counts"], sorted(usage["days"])
+    if not c and not days:
+        return "lineup report: no usage recorded in this repo yet."
+    n = lambda name: c.get(name, 0)  # noqa: E731
+    period = f" ({days[0]} to {days[-1]})" if days else ""
+    rows = [
+        ("lineup version", __version__),
+        ("Days active", f"{len(days)}{period}"),
+        ("Sessions started", n("sessions")),
+        ("Agent replies with changes", n("replies_with_changes")),
+        ("Files flagged after replies", f"HIGH {n('flagged_HIGH')}, MED {n('flagged_MED')}, LOW {n('flagged_LOW')}"),
+        ("lineup diff runs", n("diff_runs")),
+        ("lineup risky runs", n("risky_runs")),
+        ("Rollbacks", f"done {n('rollback_done')}, refused {n('rollback_refused')}, "
+                      f"failed {n('rollback_failed')}, nothing to do {n('rollback_nothing_to_do')}"),
+    ]
+    width = max(len(name) for name, _ in rows)
+    lines = ["lineup report (this repo only)", ""]
+    lines += [f"{name:<{width}}  {value}" for name, value in rows]
+    lines += ["", "That's everything in the report: counts and dates only, no code, file names or secrets.",
+              "Nothing has been sent. To share it, copy the lines above into your feedback."]
+    return "\n".join(lines)
+
+
+def _report(args):
+    root = _root()
+    if root is None:
+        return 2
+    print(report_text(store.load_usage(root)))
+    return 0
+
+
+def _confirm(args, question, flag):
+    """True to go ahead: --yes, or the user says yes. Never asks when there's no one to answer."""
+    if args.yes:
+        return True
+    if not sys.stdin.isatty():
+        print(f"\nNothing was written. Run lineup init {flag}--yes to do it.")
+        return False
+    try:
+        answer = input(f"\n{question} [y/N] ")
+    except EOFError:  # no one to answer after all (e.g. NUL on Windows looks like a terminal)
+        print(f"\nNothing was written. Run lineup init {flag}--yes to do it.")
+        return False
+    if answer.strip().lower() in ("y", "yes"):
+        return True
+    print("Nothing was written.")
+    return False
+
+
+def _init(args):
+    banner.show()
+    root = _root()
+    if root is None:
+        return 2
+    if args.remove:
+        return _init_remove(root, args)
+    agents = ["claude", "codex"] if args.agent == "both" else [args.agent]
+    plan = hooks.plan_init(root, agents)
+    if not plan:
+        print("lineup hooks are already installed. Nothing to change.")
+        for warning in hooks.tracked_warnings(root):
+            print(warning)
+        return 0
+    print("lineup init will add these hooks (your other settings stay as they are):\n")
+    for rel, (_, added) in plan.items():
+        print(f"  {rel}")
+        for event, command in added:
+            print(f"    {event:<17} {command}")
+    if any(event == "SessionStart" for _, added in plan.values() for event, _ in added):
+        note = textwrap.fill(hooks.SESSION_NOTE, 76, initial_indent="    ", subsequent_indent="    ")
+        print(f"\nAt each session start, the agent is also given this note:\n{note}")
+    if not _confirm(args, "Write these changes?", ""):
+        return 1
+    hooks.write_plan(root, plan)
+    excluded = [rel for rel in plan if hooks.keep_out_of_git(root, rel)]
+    print("\nDone.")
+    if excluded:
+        print(f"Kept out of git (added to .git/info/exclude): {', '.join(excluded)}")
+    for warning in hooks.tracked_warnings(root):
+        print(warning)
+    if any(rel.startswith(".claude") for rel in plan):
+        print("Claude Code: the hooks load in your next session (or run /hooks to check them).")
+    if any(rel.startswith(".codex") for rel in plan):
+        print("Codex: open Codex in this repo and run /hooks to review and trust the lineup hooks. "
+              "They don't run until you trust them.")
+    return 0
+
+
+def _init_remove(root, args):
+    plan = hooks.plan_remove(root)
+    if not plan:
+        print("No lineup hooks found. Nothing to remove.")
+        return 0
+    print("lineup init --remove will take out only lineup's hooks (everything else stays):\n")
+    for rel, (data, removed) in plan.items():
+        print(f"  {rel}{'  (only lineup was in it, so the file is deleted)' if data is None else ''}")
+        for event, command in removed:
+            print(f"    {event:<17} {command}")
+    if not _confirm(args, "Remove them?", "--remove "):
+        return 1
+    hooks.write_plan(root, plan)
+    print("\nDone. lineup's hooks are removed, so the agent no longer gets lineup's session-start note either.")
+    return 0
+
+
+def build_parser():
+    parser = argparse.ArgumentParser(
+        prog="lineup",
+        description="See what your coding agent just changed, which edits are risky, and undo a file.",
+    )
+    parser.add_argument("--version", action="store_true", help="show the version and exit")
+    sub = parser.add_subparsers(dest="command")
+
+    init = sub.add_parser("init", help="install the session hooks in this repo")
+    init.add_argument("--agent", choices=["both", *llm.AGENTS], default="both", help="which agent's hooks (default: both)")
+    init.add_argument("--yes", action="store_true", help="write without asking")
+    init.add_argument("--remove", action="store_true", help="remove lineup's hooks (and nothing else)")
+    init.set_defaults(func=_init)
+    sub.add_parser("diff", help="show what changed since the snapshot").set_defaults(func=_diff)
+    sub.add_parser("risky", help="score each change HIGH / MED / LOW").set_defaults(func=_risky)
+
+    undo = sub.add_parser("rollback", help="undo one or more files by ID")
+    undo.add_argument("ids", nargs="+", metavar="id_or_file",
+                      help="file IDs or names from lineup risky / diff, e.g. 3 or auth.py")
+    undo.set_defaults(func=_rollback)
+    sub.add_parser("report", help="usage counts for testers to send (nothing is sent by lineup)").set_defaults(
+        func=_report)
+
+    hook = sub.add_parser("hook", help="run by the agent's hooks (start: photo, stop: score line, prompt: notes)")
+    hook.add_argument("event", choices=["start", "stop", "prompt"])
+    hook.add_argument("--fresh", action="store_true", help="always take a new photo")
+    hook.add_argument("--agent", choices=list(llm.AGENTS), help="the agent running this session")
+    hook.set_defaults(func=_hook)
+
+    return parser
+
+
+def main(argv=None):
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if args.version or args.command is None:
+        banner.show()
+        if args.version:
+            print(f"lineup {__version__}")
+        else:
+            parser.print_help()
+        return 0
+    try:
+        return args.func(args)
+    except (OSError, ValueError, git.GitError) as error:  # one clear line, never a Python traceback
+        print(f"lineup: {error}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

lineup/functions.py

@@ -0,0 +1,152 @@
+"""Finds functions and dependencies in file contents, so changes can name them one by one."""
+
+import json
+import posixpath
+import re
+from collections import Counter
+
+_JS_KEYWORDS = {"if", "for", "while", "switch", "catch", "function", "return", "with", "else"}
+
+_PATTERNS = {
+    "python": [re.compile(r"^\s*(?:async\s+)?def\s+(\w+)\s*\(", re.M)],
+    "js": [
+        re.compile(r"\bfunction\s*\*?\s*(\w+)\s*\("),
+        re.compile(r"\b(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:function\b|\([^)]*\)\s*=>|\w+\s*=>)"),
+        re.compile(r"^\s*(?:async\s+)?(\w+)\s*\([^)]*\)\s*\{", re.M),
+    ],
+    "go": [re.compile(r"^func\s+(?:\([^)]*\)\s*)?(\w+)\s*\(", re.M)],
+}
+
+# JS test blocks: it("does x"), test.skip("does y") -> named `test "does x"`.
+_JS_TEST = re.compile(r"\b(?:it|test)(?:\.\w+)?\s*\(\s*(['\"`])(.+?)\1")
+
+_LANGUAGES = {
+    ".py": "python",
+    ".js": "js", ".jsx": "js", ".mjs": "js", ".cjs": "js", ".ts": "js", ".tsx": "js",
+    ".go": "go",
+}
+
+
+def language(path):
+    return _LANGUAGES.get(posixpath.splitext(path)[1].lower())
+
+
+def find_functions(path, text):
+    """Function names defined in `text`, as a Counter (a name can appear twice)."""
+    lang = language(path)
+    if not lang or not text:
+        return Counter()
+    names = Counter()
+    for pattern in _PATTERNS[lang]:
+        for name in pattern.findall(text):
+            if lang == "js" and name in _JS_KEYWORDS:
+                continue
+            names[name] += 1
+    if lang == "js":
+        for _, title in _JS_TEST.findall(text):
+            names[f'test "{title}"'] += 1
+    return names
+
+
+def function_changes(path, old_text, new_text):
+    """(added, removed) function names. A rename shows as one removed plus one added."""
+    old, new = find_functions(path, old_text), find_functions(path, new_text)
+    return sorted((new - old).elements()), sorted((old - new).elements())
+
+
+# ---- dependencies ----
+
+def _requirements(text):
+    names = set()
+    for line in text.splitlines():
+        line = line.split("#", 1)[0].strip()
+        if not line or line.startswith("-"):
+            continue
+        name = re.split(r"[<>=!~\[;@\s]", line, maxsplit=1)[0]
+        if name:
+            names.add(name.lower())
+    return names
+
+
+def _package_json(text):
+    try:
+        data = json.loads(text)
+    except ValueError:
+        return set()
+    names = set()
+    for key in ("dependencies", "devDependencies", "peerDependencies", "optionalDependencies"):
+        section = data.get(key)
+        if isinstance(section, dict):
+            names.update(section)
+    return names
+
+
+def _toml_sections(text, wanted):
+    """Keys inside TOML tables whose name passes `wanted(table_name)`."""
+    names, inside = set(), False
+    for line in text.splitlines():
+        stripped = line.strip()
+        if stripped.startswith("["):
+            inside = wanted(stripped.strip("[]").strip())
+            continue
+        if inside:
+            match = re.match(r"([A-Za-z0-9_.\-]+)\s*=", stripped)
+            if match and match.group(1).lower() != "python":
+                names.add(match.group(1).lower())
+    return names
+
+
+def _pyproject(text):
+    names = set()
+    # PEP 621 lists: dependencies = ["requests>=2", ...] (also optional-dependencies groups)
+    for block in re.findall(r"^\s*[\w-]*dependencies\s*=\s*\[(.*?)\]", text, re.M | re.S):
+        for spec in re.findall(r"['\"]([^'\"]+)['\"]", block):
+            names |= _requirements(spec)
+    # Poetry tables: [tool.poetry.dependencies] / [tool.poetry.group.dev.dependencies]
+    names |= _toml_sections(text, lambda t: t.startswith("tool.poetry") and t.endswith("dependencies"))
+    return names
+
+
+def _cargo(text):
+    return _toml_sections(text, lambda t: t.endswith("dependencies"))
+
+
+def _pipfile(text):
+    return _toml_sections(text, lambda t: t in ("packages", "dev-packages"))
+
+
+def _go_mod(text):
+    names = set()
+    for block in re.findall(r"^require\s*\((.*?)\)", text, re.M | re.S):
+        names.update(re.findall(r"^\s*(\S+)\s+v", block, re.M))
+    names.update(re.findall(r"^require\s+(\S+)\s+v", text, re.M))
+    return names
+
+
+def _dependency_parser(path):
+    name = posixpath.basename(path).lower()
+    if name == "package.json":
+        return _package_json
+    if name == "pyproject.toml":
+        return _pyproject
+    if name == "cargo.toml":
+        return _cargo
+    if name == "pipfile":
+        return _pipfile
+    if name == "go.mod":
+        return _go_mod
+    if re.fullmatch(r"requirements.*\.txt", name):
+        return _requirements
+    return None
+
+
+def is_dependency_file(path):
+    return _dependency_parser(path) is not None
+
+
+def new_dependencies(path, old_text, new_text):
+    """Packages listed in `new_text` but not in `old_text`, sorted."""
+    parser = _dependency_parser(path)
+    if not parser:
+        return []
+    return sorted(parser(new_text or "") - parser(old_text or ""))