git-trace 1.0.0__py3-none-any.whl

git_trace/__init__.py

@@ -0,0 +1,6 @@
+from .version import VERSION, __version__
+
+__all__ = (
+    "__version__",
+    "VERSION",
+)

git_trace/__main__.py

@@ -0,0 +1,3 @@
+from git_trace.main import main
+
+main()

git_trace/analysis.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+import re
+from collections import defaultdict
+from dataclasses import dataclass, field
+
+from git_trace.git import Commit
+
+
+HUNK_HEADER_PATTERN: re.Pattern[str] = re.compile(r'^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@')
+
+
+@dataclass
+class DiffHunk:
+    old_start: int
+    old_count: int
+    new_start: int
+    new_count: int
+    lines: list[tuple[str, str]] = field(default_factory=list)
+
+
+@dataclass
+class FileChange:
+    path: str
+    old_path: str | None = None
+    hunks: list[DiffHunk] = field(default_factory=list)
+
+
+@dataclass
+class VirtualLine:
+    content: str
+    owner_hash: str | None
+
+
+@dataclass
+class DependencyGraph:
+    relationships: dict[str, set[str]] = field(default_factory=lambda: defaultdict(set))
+
+    def add_dependency(self, commit_hash: str, parent_hash: str) -> None:
+        self.relationships[commit_hash].add(parent_hash)
+
+    def get_dependencies_for(self, commit_hash: str) -> set[str]:
+        return self.relationships.get(commit_hash, set())
+
+
+@dataclass
+class CherryPickAnalysis:
+    safe: list[str] = field(default_factory=list)
+    conditional: list[str] = field(default_factory=list)
+    blocked: dict[str, set[str]] = field(default_factory=dict)
+
+
+def _parse_diff(diff_text: str, ignore_paths: set[str]) -> list[FileChange]:
+    changes: list[FileChange] = []
+    current_change: FileChange | None = None
+    current_hunk: DiffHunk | None = None
+    rename_from: str | None = None
+    old_path_candidate: str | None = None
+
+    for line in diff_text.splitlines():
+        if line.startswith("diff --git "):
+            if current_change is not None:
+                changes.append(current_change)
+            current_change = None
+            current_hunk = None
+            rename_from = None
+            old_path_candidate = None
+        elif line.startswith("rename from "):
+            rename_from = line[len("rename from "):].replace("\\", "/")
+        elif line.startswith("rename to "):
+            rename_to: str = line[len("rename to "):].replace("\\", "/")
+            if rename_to not in ignore_paths:
+                current_change = FileChange(path=rename_to, old_path=rename_from)
+        elif line.startswith("--- "):
+            current_hunk = None
+            old_path_candidate = line[6:].replace("\\", "/") if line.startswith("--- a/") else None
+        elif line.startswith("+++ "):
+            current_hunk = None
+            new_path: str | None = line[6:].replace("\\", "/") if line.startswith("+++ b/") else None
+            canonical_path: str | None = new_path or old_path_candidate
+            if canonical_path is None or canonical_path in ignore_paths:
+                current_change = None
+            elif current_change is not None and current_change.path == canonical_path:
+                pass
+            else:
+                old: str | None = old_path_candidate if (old_path_candidate and new_path and old_path_candidate != new_path) else None
+                current_change = FileChange(path=canonical_path, old_path=old)
+        elif current_change is not None:
+            hunk_match: re.Match[str] | None = HUNK_HEADER_PATTERN.match(line)
+            if hunk_match:
+                old_start: int = int(hunk_match.group(1))
+                old_count: int = int(hunk_match.group(2)) if hunk_match.group(2) is not None else 1
+                new_start: int = int(hunk_match.group(3))
+                new_count: int = int(hunk_match.group(4)) if hunk_match.group(4) is not None else 1
+                current_hunk = DiffHunk(
+                    old_start=old_start,
+                    old_count=old_count,
+                    new_start=new_start,
+                    new_count=new_count,
+                )
+                current_change.hunks.append(current_hunk)
+            elif current_hunk is not None and line and line[0] in ("+", "-", " "):
+                current_hunk.lines.append((line[0], line[1:]))
+
+    if current_change is not None:
+        changes.append(current_change)
+    return changes
+
+
+# wild opus dependency graph building logic
+def build_dependency_graph(commits: list[Commit], raw_diffs: dict[str, str], ignore_paths: set[str] | None = None) -> DependencyGraph:
+    virtual_files: dict[str, list[VirtualLine]] = {}
+    graph: DependencyGraph = DependencyGraph()
+    ignore_paths = ignore_paths or set()
+
+    for commit in commits:
+        diff_text: str = raw_diffs.get(commit.hash, "")
+        file_changes: list[FileChange] = _parse_diff(diff_text, ignore_paths)
+
+        for change in file_changes:
+            if change.old_path is not None and change.old_path in virtual_files:
+                virtual_files[change.path] = virtual_files.pop(change.old_path)
+            else:
+                virtual_files.setdefault(change.path, [])
+
+            virtual_file: list[VirtualLine] = virtual_files[change.path]
+            cumulative_offset: int = 0
+
+            for hunk in change.hunks:
+                position: int = (
+                    hunk.old_start if hunk.old_count == 0
+                    else max(0, hunk.old_start - 1)
+                ) + cumulative_offset
+
+                while len(virtual_file) < position + hunk.old_count:
+                    virtual_file.append(VirtualLine(content="", owner_hash=None))
+
+                new_entries: list[VirtualLine] = []
+                old_index: int = position
+
+                for line_type, content in hunk.lines:
+                    if line_type == " ":
+                        new_entries.append(virtual_file[old_index])
+                        old_index += 1
+                    elif line_type == "-":
+                        existing_line = virtual_file[old_index]
+                        if existing_line.owner_hash is not None and existing_line.owner_hash != commit.hash:
+                            graph.add_dependency(commit.hash, existing_line.owner_hash)
+                        old_index += 1
+                    elif line_type == "+":
+                        new_entries.append(VirtualLine(content=content, owner_hash=commit.hash))
+
+                virtual_file[position:position + hunk.old_count] = new_entries
+                cumulative_offset += hunk.new_count - hunk.old_count
+
+    return graph
+
+
+def filter_picks(pick_hashes: set[str], graph: DependencyGraph) -> CherryPickAnalysis:
+    blocked: dict[str, set[str]] = {}
+    for commit_hash in pick_hashes:
+        missing: set[str] = graph.get_dependencies_for(commit_hash) - pick_hashes
+        if missing:
+            blocked[commit_hash] = missing
+
+    tainted: set[str] = set(blocked.keys())
+    changed: bool = True
+    while changed:
+        changed = False
+        for commit_hash in pick_hashes:
+            if commit_hash not in tainted:
+                in_pick_dependencies: set[str] = graph.get_dependencies_for(commit_hash) & pick_hashes
+                if in_pick_dependencies & tainted:
+                    tainted.add(commit_hash)
+                    changed = True
+
+    conditional: list[str] = [commit_hash for commit_hash in pick_hashes if commit_hash in tainted and commit_hash not in blocked]
+    safe: list[str] = [commit_hash for commit_hash in pick_hashes if commit_hash not in tainted]
+    return CherryPickAnalysis(
+        safe=safe,
+        conditional=conditional,
+        blocked=blocked
+    )

git_trace/git.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Commit:
+    hash: str
+    message: str
+
+    def is_inside_hash_set(self, hash_set: set[str]) -> bool:
+        return any(self.hash.startswith(prefix) or prefix.startswith(self.hash) for prefix in hash_set)
+
+
+def run_git(*args: str, repo_directory: str) -> str:
+    command: list[str] = ["git"]
+    if repo_directory:
+        command += ["-C", repo_directory]
+    command += list(args)
+    process: subprocess.CompletedProcess[str] = subprocess.run(
+        command, capture_output=True, encoding="utf-8", errors="replace"
+    )
+    return process.stdout or ""
+
+
+def get_commits(branch: str, repo_directory: str, after: str | None = None, before: str | None = None) -> list[Commit]:
+    scope: str = f"{after if after else ''}{'..' if after else ''}{before if before else branch}"
+    output: str = run_git("log", scope, "--reverse", "--format=%H %s", repo_directory=repo_directory)
+
+    commits: list[Commit] = []
+    for line in output.splitlines():
+        line = line.strip()
+        if line:
+            commit_hash, _, message = line.partition(" ")
+            commits.append(Commit(hash=commit_hash, message=message))
+
+    if before and commits: # skip last commit to exclude it
+        commits.pop()
+
+    return commits
+
+
+def get_commit_diff(sha: str, repo_directory: str) -> str:
+    return run_git("show", "--format=", "-p", sha, repo_directory=repo_directory)
+
+
+def resolve_hashes(hashes: list[str], all_commits: list[Commit]) -> dict[str, str | None]:
+    full_hashes: list[str] = [commit.hash for commit in all_commits]
+    result: dict[str, str | None] = {}
+    for hash_ in hashes: # if user provided short hashes map them to full hashes if possible
+        matches: list[str] = [full_hash for full_hash in full_hashes if full_hash.lower().startswith(hash_.lower())]
+        result[hash_] = matches[0] if len(matches) == 1 else None
+    return result

git_trace/input/args.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import argparse
+import copy
+import os
+from dataclasses import dataclass
+from typing import Any, Callable
+
+import yaml
+
+from git_trace.input.parser import build_cli_parser
+from git_trace.utils import cprint, WARNING_COLOR, yaml2list, INFO_COLOR, read_cleaned_file
+
+
+@dataclass(frozen=True)
+class ArgumentDefinition:
+    identifier: str
+    yaml_identifier: str | None = None
+    conversion_from_yaml: Callable | None = None
+    default_value: Any | None = None
+
+
+CLI_ARGUMENTS_LIST: tuple[ArgumentDefinition, ...] = (
+    #                  Identifier      YAML Key        Converter       Default Value
+    ArgumentDefinition("after",        "after",        bool),
+    ArgumentDefinition("before",       "before",       str),
+    ArgumentDefinition("blacklist",    "blacklist", yaml2list, "blacklist.txt"),
+    ArgumentDefinition("branch",       "branch",       str,            "main"),
+    ArgumentDefinition("config",                                       default_value="config.yml"),
+    ArgumentDefinition("ignore_paths", "ignore-paths", yaml2list, "ignore_paths.txt"),
+    ArgumentDefinition("list",                                         default_value=False),
+    ArgumentDefinition("no_graph",     "no-graph",     bool,           False),
+    ArgumentDefinition("output",       "output",       str,            "./output.html"),
+    ArgumentDefinition("picks",        "picks", yaml2list, "picks.txt"),
+    ArgumentDefinition("repo",         "repo",         str,            "./"),
+    ArgumentDefinition("txt_output",   "txt-output",   str),
+    ArgumentDefinition("whitelist",    "whitelist", yaml2list, "whitelist.txt"),
+)
+CLI_ARGUMENTS: dict[str, ArgumentDefinition] = {arg.identifier: arg for arg in CLI_ARGUMENTS_LIST}
+
+
+def build_args_dict() -> dict[str, Any]:
+    parser: argparse.ArgumentParser = build_cli_parser()
+    args: argparse.Namespace = parser.parse_args()
+
+    provided_via_cli: set[str] = {
+        arg.identifier
+        for arg in CLI_ARGUMENTS_LIST
+        if hasattr(args, arg.identifier)
+    }
+
+    config_path: str = getattr(args, "config", None) or "./config.yml"
+    config: dict[str, Any] | None = _load_config(config_path)
+    if config:
+        args = _fill_out_args_with_config_values(args, config, provided_via_cli)
+
+    args.blacklist = _check_if_autoloading_list_input(getattr(args, "blacklist", None), "./blacklist.txt", "blacklist")
+    args.ignore_paths = _check_if_autoloading_list_input(getattr(args, "ignore_paths", None), "./ignore_paths.txt", "ignore_paths")
+    args.picks = _check_if_autoloading_list_input(getattr(args, "picks", None), "./picks.txt", "picks")
+    args.whitelist = _check_if_autoloading_list_input(getattr(args, "whitelist", None), "./whitelist.txt", "whitelist")
+
+    blacklist: set[str] | None = _resolve_hash_list_input(args.blacklist, "blacklist") if args.blacklist else None
+    ignore_paths: set[str] = _resolve_file_paths_input(args.ignore_paths, "ignore_paths") if args.ignore_paths else None
+    picks: set[str] | None = _resolve_hash_list_input(args.picks, "picks") if args.picks else None
+    whitelist: set[str] | None = _resolve_hash_list_input(args.whitelist, "whitelist") if args.whitelist else None
+
+    result: dict[str, Any] = {
+        "after":        getattr(args, "after", None)        or CLI_ARGUMENTS["after"].default_value,
+        "before":       getattr(args, "before", None)       or CLI_ARGUMENTS["before"].default_value,
+        "blacklist":    blacklist,
+        "branch":       getattr(args, "branch", None)       or CLI_ARGUMENTS["branch"].default_value,
+        "config":       getattr(args, "config", None)       or CLI_ARGUMENTS["config"].default_value,
+        "ignore-paths": ignore_paths,
+        "list":         getattr(args, "list", None)         or CLI_ARGUMENTS["list"].default_value,
+        "no-graph":     getattr(args, "no_graph", None)     or CLI_ARGUMENTS["no_graph"].default_value,
+        "output":       getattr(args, "output", None)       or CLI_ARGUMENTS["output"].default_value,
+        "picks":        picks,
+        "repo":         getattr(args, "repo", None)         or CLI_ARGUMENTS["repo"].default_value,
+        "txt-output":   getattr(args, "txt_output", None)   or CLI_ARGUMENTS["txt_output"].default_value,
+        "whitelist":    whitelist,
+    }
+    return result
+
+
+def _load_config(path: str) -> dict[str, Any] | None:
+    if not os.path.isfile(path):
+        return None
+
+    with open(path, "r", encoding="utf-8") as file:
+        data: dict[str, Any] | None = yaml.safe_load(file) or None
+
+    if data is None or not isinstance(data, dict):
+        cprint(f"[WARNING] Could not load config from '{path}', check if it's a correct YAML mapping, ignoring.", color=WARNING_COLOR)
+        return None
+
+    cprint(f"[INFO] Loaded config from '{path}'.", color=INFO_COLOR)
+    return data
+
+
+def _fill_out_args_with_config_values(args: argparse.Namespace, config: dict[str, Any], provided_via_cli: set[str]) -> argparse.Namespace:
+    new_args: argparse.Namespace = copy.deepcopy(args)
+
+    for argument in CLI_ARGUMENTS_LIST:
+        if argument.identifier in provided_via_cli or argument.yaml_identifier is None:
+            continue
+        raw_value: Any = config.get(argument.yaml_identifier)
+        if raw_value is None:
+            continue
+
+        if argument.conversion_from_yaml is None:
+            converted_value: Any = raw_value
+        else:
+            converted_value: Any = argument.conversion_from_yaml(raw_value)
+
+        if converted_value is not None:
+            setattr(new_args, argument.identifier, converted_value)
+
+    return new_args
+
+
+def _check_if_autoloading_list_input(values: list[str] | None, default_file_path: str, argument_identifier: str) -> list[str] | None:
+    if values is not None:
+        return values
+    if os.path.isfile(default_file_path):
+        cprint(f"[INFO] Auto-loading {argument_identifier} from '{default_file_path}'")
+        return [default_file_path]
+    return None
+
+
+def _resolve_hash_list_input(values: list[str], argument_identifier: str) -> set[str]:
+    if len(values) == 1 and os.path.isfile(file_path := values[0]):
+        loaded: set[str] = _load_commit_set(file_path)
+        cprint(f"[INFO] Loaded {len(loaded)} {'hash' if len(loaded) == 1 else 'hashes'} from '{file_path}' (via {argument_identifier})", color=INFO_COLOR)
+        return loaded
+    return {hash_.lower() for hash_ in values}
+
+
+def _resolve_file_paths_input(values: list[str], argument_identifier: str) -> set[str]:
+    if len(values) == 1 and os.path.isfile(file_path := values[0]):
+        loaded: set[str] = _load_ignore_paths(file_path)
+        cprint(f"[INFO] Loaded {len(loaded)} {'path' if len(loaded) == 1 else 'paths'} from '{file_path}' (via {argument_identifier})", color=INFO_COLOR)
+        return loaded
+    return {path.replace("\\", "/") for path in values}
+
+
+def _load_commit_set(path: str) -> set[str]:
+    return {line.lower() for line in read_cleaned_file(path)}
+
+
+def _load_ignore_paths(path: str) -> set[str]:
+    return {line.replace("\\", "/") for line in read_cleaned_file(path)}

git_trace/input/parser.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import argparse
+
+from git_trace import __version__
+from git_trace.utils import Color
+
+
+def build_cli_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="git-trace",
+        description="Visualise and analyse git commit dependencies.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=(
+            f" A {Color.BOLD.value}{Color.BRIGHT_BLUE.value}config.yml{Color.RESET.value} file if present in the current directory is loaded automatically and"
+            " can set any of these options. CLI arguments take priority over config.yml,"
+            " which takes priority over .txt auto-load files.\n\n"
+            "examples:\n"
+            f"  {Color.BOLD.value}{Color.MAGENTA.value}git-trace                                     {Color.RESET.value}# analyse main, full history\n"
+            f"  {Color.BOLD.value}{Color.MAGENTA.value}git-trace {Color.GREEN.value}dev {Color.CYAN.value}--after {Color.YELLOW.value}abc1234                 {Color.RESET.value}# analyse dev after a commit\n"
+            f"  {Color.BOLD.value}{Color.MAGENTA.value}git-trace {Color.GREEN.value}dev {Color.CYAN.value}--after {Color.YELLOW.value}abc {Color.CYAN.value}--before {Color.YELLOW.value}def        {Color.RESET.value}# analyse a commit range\n"
+            f"  {Color.BOLD.value}{Color.MAGENTA.value}git-trace {Color.GREEN.value}dev {Color.CYAN.value}--whitelist {Color.YELLOW.value}picks.txt           {Color.RESET.value}# whitelist via file\n"
+            f"  {Color.BOLD.value}{Color.MAGENTA.value}git-trace {Color.GREEN.value}dev {Color.CYAN.value}--whitelist {Color.YELLOW.value}h1 h2 h3            {Color.RESET.value}# whitelist inline\n"
+            f"  {Color.BOLD.value}{Color.MAGENTA.value}git-trace {Color.GREEN.value}dev {Color.CYAN.value}--no-graph                      {Color.RESET.value}# text-only output\n"
+            f"  {Color.BOLD.value}{Color.MAGENTA.value}git-trace {Color.GREEN.value}dev {Color.CYAN.value}--after {Color.YELLOW.value}abc {Color.CYAN.value}--picks {Color.YELLOW.value}h1 h2       {Color.RESET.value}# check if cherry picking is safe\n"
+            f"  {Color.BOLD.value}{Color.MAGENTA.value}git-trace {Color.GREEN.value}dev {Color.CYAN.value}--picks {Color.YELLOW.value}picks.txt               {Color.RESET.value}# cherry pick safety check via file\n"
+        ).strip(),
+    )
+    # positional args
+    parser.add_argument(
+        "branch",
+        nargs="?",
+        default=argparse.SUPPRESS,
+        help=f"branch to analyse {Color.BRIGHT_BLACK.value}(default: main){Color.RESET.value}.",
+    )
+    # optional args
+    parser.add_argument(
+        "--after",
+        metavar="HASH",
+        default=argparse.SUPPRESS,
+        help=f"only include commits after this hash {Color.BRIGHT_BLACK.value}(excluding it){Color.RESET.value}.",
+    )
+    parser.add_argument(
+        "--before",
+        metavar="HASH",
+        default=argparse.SUPPRESS,
+        help=f"only include commits up to this hash {Color.BRIGHT_BLACK.value}(excluding it){Color.RESET.value}.",
+    )
+    parser.add_argument(
+        "--blacklist",
+        nargs="+",
+        metavar="HASH_OR_FILE",
+        default=argparse.SUPPRESS,
+        help=(
+            f"commit hashes to ignore during analysis, OR a single path to a file containing them {Color.BRIGHT_BLACK.value}(one per line){Color.RESET.value}. "
+            "Auto-loaded from blacklist.txt if the file exists and the flag is omitted."
+        ),
+    )
+    parser.add_argument(
+        "--config",
+        metavar="FILE",
+        default=argparse.SUPPRESS,
+        help=f"path to a YAML config file {Color.BRIGHT_BLACK.value}(default: config.yml){Color.RESET.value}. Values are overridden by explicit CLI args.",
+    )
+    parser.add_argument(
+        "--ignore-paths",
+        nargs="+",
+        metavar="PATH_OR_FILE",
+        default=argparse.SUPPRESS,
+        help=(
+            "repo-relative paths to exclude from diff analysis, OR a single path to a "
+            f"file containing them {Color.BRIGHT_BLACK.value}(one per line){Color.RESET.value}. "
+            "Auto-loaded from ignore-paths.txt if the file exists and the flag is omitted."
+        ),
+    )
+    parser.add_argument(
+        "--list",
+        action="store_true",
+        default=argparse.SUPPRESS,
+        help=(
+            f"works only if used alongside --picks. Prints a simple list of blocked commit hashes {Color.BRIGHT_BLACK.value}(one per line, outputs nothing if no dependencies are found){Color.RESET.value} instead of the formatted text tree. "
+            "Combine with --no-graph to suppress HTML output as well."
+        ),
+    )
+    parser.add_argument(
+        "--no-graph",
+        action="store_true",
+        default=argparse.SUPPRESS,
+        help="skip HTML graph generation and print only the text output.",
+    )
+    parser.add_argument(
+        "--output",
+        metavar="PATH",
+        default=argparse.SUPPRESS,
+        help=f"output path for the HTML graph {Color.BRIGHT_BLACK.value}(default: output.html){Color.RESET.value}.",
+    )
+    parser.add_argument(
+        "--picks",
+        nargs="+",
+        metavar="HASH_OR_FILE",
+        default=argparse.SUPPRESS,
+        help=(
+            "commit hashes to cherry-pick, OR a single path to a file containing them. "
+            "When provided, analysis additionally reports which commits are safe to "
+            "pick and which are blocked by missing dependencies. "
+            "Auto-loaded from picks.txt if the file exists and the flag is omitted."
+        ),
+    )
+    parser.add_argument(
+        "--repo",
+        metavar="DIR",
+        default=argparse.SUPPRESS,
+        help=f"path to the git repository root {Color.BRIGHT_BLACK.value}(default: current directory){Color.RESET.value}.",
+    )
+    parser.add_argument(
+        "--txt-output",
+        metavar="PATH",
+        default=argparse.SUPPRESS,
+        help="write the text output to this file.",
+    )
+    parser.add_argument(
+        "-v", "--version",
+        action="version",
+        version=f"git-trace {__version__}",
+    )
+    parser.add_argument(
+        "--whitelist",
+        nargs="+",
+        metavar="HASH_OR_FILE",
+        default=argparse.SUPPRESS,
+        help=(
+            "only analyse these commit hashes, OR a single path to a file "
+            f"containing them {Color.BRIGHT_BLACK.value}(one per line){Color.RESET.value}. Runs before --blacklist logic. "
+            "Auto-loaded from whitelist.txt if the file exists and the flag is omitted."
+        ),
+    )
+
+    return parser

git_trace/main.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+import os
+import sys
+from typing import Any
+
+import colorama
+
+from git_trace.analysis import build_dependency_graph, filter_picks, CherryPickAnalysis, DependencyGraph
+from git_trace.git import get_commit_diff, get_commits, Commit, resolve_hashes
+from git_trace.input.args import build_args_dict
+from git_trace.output.graph import display_pick_graph, display_graph
+from git_trace.output.text import print_pick_result, print_pick_list, print_text_tree
+from git_trace.utils import cprint, Color, SHORT_HASH_LENGTH, ERROR_COLOR, WARNING_COLOR, MAX_COMMIT_MESSAGE_LENGTH
+
+
+def main():
+    colorama.init()
+    args: dict[str, Any] = build_args_dict()
+
+    git_directory_path: str = os.path.join(args["repo"], ".git")
+    if not os.path.isdir(git_directory_path):
+        cprint(
+            f"[ERROR] .git directory not found in '{os.path.abspath(args['repo'])}'. "
+            "Run git-trace from the root of your git repository, "
+            "or use --repo to specify the path.",
+            color=ERROR_COLOR,
+        )
+        sys.exit(1)
+
+    commits: list[Commit] = _fetch_commits(args["branch"], args["repo"], args["after"], args["before"], args["list"])
+    if not commits:
+        cprint("[ERROR] No commits found. Check that the branch name and hash bounds are correct, exiting...", color=ERROR_COLOR)
+        sys.exit(2)
+
+    if args["whitelist"] and args["blacklist"]:
+        cprint("[WARNING] Both --whitelist and --blacklist provided, --whitelist takes priority and runs before --blacklist logic.", color=WARNING_COLOR)
+
+    commit_count_before_filtering: int = len(commits)
+    if args["whitelist"]:
+        commits = [commit for commit in commits if commit.is_inside_hash_set(args["whitelist"])]
+        cprint(f"Selected {len(commits)} out of {commit_count_before_filtering} commit(s) due to whitelist.")
+    commit_count_after_whitelisting: int = len(commits)
+    if args["blacklist"]:
+        commits = [commit for commit in commits if not commit.is_inside_hash_set(args["blacklist"])]
+        cprint(f"Skipped {commit_count_after_whitelisting - len(commits)} blacklisted commit(s).")
+
+    if not commits:
+        cprint("[ERROR] No commits left after applying filters, exiting...", color=ERROR_COLOR)
+        sys.exit(3)
+
+    if not args["list"]:
+        cprint(f"Selected {len(commits)} commit(s). Analysing diffs...")
+
+    raw_diffs: dict[str, str] = _fetch_diffs(commits, args["repo"], args["list"])
+    commits_hash_dict: dict[str, Commit] = {commit.hash: commit for commit in commits}
+
+    if not args["list"]:
+        cprint("Building dependency graph...")
+    dependency_graph: DependencyGraph = build_dependency_graph(commits, raw_diffs, args["ignore-paths"])
+    dependency_count: int = sum(1 for dep_set in dependency_graph.relationships.values() if dep_set)
+    if not args["list"]:
+        cprint(f"  {dependency_count} commit(s) have at least one dependency.\n")
+
+    if args["picks"]:
+        resolved: dict[str, str | None] = resolve_hashes(list(args["picks"]), commits)
+        unknown_hashes: list[str] = [short_hash for short_hash, full_hash in resolved.items() if full_hash is None]
+        if unknown_hashes:
+            cprint("[WARNING] The following hashes were not found in the analyzed range and will be skipped:", color=WARNING_COLOR)
+            for short_hash in unknown_hashes:
+                cprint(f"{' '*4}{short_hash}")
+
+        full_pick_hashes: set[str] = {full_hash for full_hash in resolved.values() if full_hash is not None}
+        cherry_pick_analysis: CherryPickAnalysis = filter_picks(full_pick_hashes, dependency_graph)
+
+        if args["list"]:
+            print_pick_list(cherry_pick_analysis.blocked, commits_hash_dict)
+        else:
+            print_pick_result(cherry_pick_analysis, commits_hash_dict, txt_output_path=args["txt-output"])
+
+        if not args["no-graph"]:
+            display_pick_graph(commits, commits_hash_dict, dependency_graph, cherry_pick_analysis, output_path=args["output"])
+    else:
+        print_text_tree(commits, commits_hash_dict, dependency_graph, txt_output_path=args["txt-output"])
+
+        if not args["no-graph"]:
+            display_graph(commits, commits_hash_dict, dependency_graph, output_path=args["output"])
+
+
+def _fetch_commits(branch: str, repo_directory: str, after: str | None, before: str | None, using_list_arg: bool = False) -> list[Commit]:
+    message_parts: list[str] = [f"Fetching commits on '{Color.BRIGHT_BLUE.value}{branch}{Color.RESET.value}'"]
+    if after:
+        message_parts.append(f"after {Color.BRIGHT_BLUE.value}{after[:SHORT_HASH_LENGTH]}{Color.RESET.value}")
+    if before:
+        message_parts.append(f"up to {before[:SHORT_HASH_LENGTH]}")
+    if not using_list_arg:
+        cprint(" ".join(message_parts) + "...")
+
+    return get_commits(branch=branch, after=after, before=before, repo_directory=repo_directory)
+
+
+def _fetch_diffs(commits: list[Commit], repo_directory: str, using_list_arg: bool = False) -> dict[str, str]:
+    raw_diffs: dict[str, str] = {}
+    commit_count: int = len(commits)
+    message_index_padding_width: int = len(str(commit_count))
+    for index, commit in enumerate(commits, 1):
+        if not using_list_arg:
+            message_index_prefix: str = f"[{index:>{message_index_padding_width}}/{commit_count}]"
+            cprint(f"  {message_index_prefix}  {commit.hash[:SHORT_HASH_LENGTH]}  {commit.message[:MAX_COMMIT_MESSAGE_LENGTH]}")
+        raw_diffs[commit.hash] = get_commit_diff(commit.hash, repo_directory=repo_directory)
+    return raw_diffs
+
+
+if __name__ == "__main__":
+    main()