gitdirector 0.1.5__tar.gz

gitdirector-0.1.5/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.3
+Name: gitdirector
+Version: 0.1.5
+Summary: A Python CLI tool for managing and synchronizing multiple git repositories with ease
+Keywords: git,repository,manager,cli,synchronization,batch
+Author: Anito Anto
+Author-email: Anito Anto <49053859+anitoanto@users.noreply.github.com>
+License: MIT
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: click>=8.1.0
+Requires-Dist: rich>=12.0
+Requires-Dist: pytest>=7.0 ; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0 ; extra == 'dev'
+Requires-Dist: black>=23.0 ; extra == 'dev'
+Requires-Dist: ruff>=0.1.0 ; extra == 'dev'
+Requires-Dist: mypy>=1.0 ; extra == 'dev'
+Requires-Dist: build>=1.0 ; extra == 'dev'
+Requires-Dist: twine>=4.0 ; extra == 'dev'
+Maintainer: Anito Anto
+Maintainer-email: Anito Anto <49053859+anitoanto@users.noreply.github.com>
+Requires-Python: >=3.9
+Project-URL: Homepage, https://github.com/anitoanto/gitdirector
+Project-URL: Repository, https://github.com/anitoanto/gitdirector.git
+Project-URL: Issues, https://github.com/anitoanto/gitdirector/issues
+Project-URL: Documentation, https://github.com/anitoanto/gitdirector/blob/main/README.md
+Provides-Extra: dev
+Description-Content-Type: text/markdown
+
+# GitDirector
+
+A Python CLI tool for managing and synchronizing multiple git repositories.
+
+## Installation
+
+```bash
+pip install gitdirector
+```
+
+## Usage
+
+```
+gitdirector add PATH [--discover]     Add a repository or discover all under a path
+gitdirector remove PATH [--discover]  Remove a repository or all under a path
+gitdirector list                      List all tracked repositories with live status
+gitdirector status                    Show dirty repositories with staged/unstaged files
+gitdirector pull                      Pull latest changes for all tracked repositories
+gitdirector help                      Show help
+```
+
+### add
+
+```bash
+gitdirector add /path/to/repo
+gitdirector add /path/to/folder --discover   # recursively find and add all repos
+```
+
+### remove
+
+```bash
+gitdirector remove /path/to/repo
+gitdirector remove /path/to/folder --discover
+```
+
+### list
+
+Displays a live table of all tracked repositories with:
+
+- Sync state: `up to date`, `ahead`, `behind`, `diverged`, or `unknown`
+- Current branch
+- Staged/unstaged changes
+- Last commit (relative time)
+- Tracked file size
+- Path
+
+Checks run concurrently (default: 10 workers).
+
+### status
+
+Shows repositories with uncommitted changes (staged and/or unstaged files). Prints a summary of total, clean, and changed repo counts.
+
+### pull
+
+Pulls all tracked repositories concurrently using fast-forward only (`git pull --ff-only`). Reports success or failure per repository.
+
+## Configuration
+
+Config is stored at `~/.gitdirector/config.yaml`.
+
+```yaml
+repositories:
+  - /path/to/repo1
+  - /path/to/repo2
+max_workers: 10   # optional, default 10
+```
+
+## Requirements
+
+- Python 3.9+
+- Git
+
+## License
+
+MIT

gitdirector-0.1.5/README.md

@@ -0,0 +1,75 @@
+# GitDirector
+
+A Python CLI tool for managing and synchronizing multiple git repositories.
+
+## Installation
+
+```bash
+pip install gitdirector
+```
+
+## Usage
+
+```
+gitdirector add PATH [--discover]     Add a repository or discover all under a path
+gitdirector remove PATH [--discover]  Remove a repository or all under a path
+gitdirector list                      List all tracked repositories with live status
+gitdirector status                    Show dirty repositories with staged/unstaged files
+gitdirector pull                      Pull latest changes for all tracked repositories
+gitdirector help                      Show help
+```
+
+### add
+
+```bash
+gitdirector add /path/to/repo
+gitdirector add /path/to/folder --discover   # recursively find and add all repos
+```
+
+### remove
+
+```bash
+gitdirector remove /path/to/repo
+gitdirector remove /path/to/folder --discover
+```
+
+### list
+
+Displays a live table of all tracked repositories with:
+
+- Sync state: `up to date`, `ahead`, `behind`, `diverged`, or `unknown`
+- Current branch
+- Staged/unstaged changes
+- Last commit (relative time)
+- Tracked file size
+- Path
+
+Checks run concurrently (default: 10 workers).
+
+### status
+
+Shows repositories with uncommitted changes (staged and/or unstaged files). Prints a summary of total, clean, and changed repo counts.
+
+### pull
+
+Pulls all tracked repositories concurrently using fast-forward only (`git pull --ff-only`). Reports success or failure per repository.
+
+## Configuration
+
+Config is stored at `~/.gitdirector/config.yaml`.
+
+```yaml
+repositories:
+  - /path/to/repo1
+  - /path/to/repo2
+max_workers: 10   # optional, default 10
+```
+
+## Requirements
+
+- Python 3.9+
+- Git
+
+## License
+
+MIT

gitdirector-0.1.5/pyproject.toml

@@ -0,0 +1,92 @@
+[build-system]
+requires = ["uv_build>=0.11.2,<0.12.0"]
+build-backend = "uv_build"
+
+[project]
+name = "gitdirector"
+version = "0.1.5"
+description = "A Python CLI tool for managing and synchronizing multiple git repositories with ease"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [
+    { name = "Anito Anto", email = "49053859+anitoanto@users.noreply.github.com" }
+]
+maintainers = [
+    { name = "Anito Anto", email = "49053859+anitoanto@users.noreply.github.com" }
+]
+requires-python = ">=3.9"
+keywords = ["git", "repository", "manager", "cli", "synchronization", "batch"]
+classifiers = [
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Version Control :: Git",
+]
+dependencies = [
+    "pyyaml>=6.0",
+    "click>=8.1.0",
+    "rich>=12.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+    "black>=23.0",
+    "ruff>=0.1.0",
+    "mypy>=1.0",
+    "build>=1.0",
+    "twine>=4.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/anitoanto/gitdirector"
+Repository = "https://github.com/anitoanto/gitdirector.git"
+Issues = "https://github.com/anitoanto/gitdirector/issues"
+Documentation = "https://github.com/anitoanto/gitdirector/blob/main/README.md"
+
+[project.scripts]
+gitdirector = "gitdirector.cli:main"
+
+[tool.uv]
+managed = true
+
+[dependency-groups]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+    "pytest-mock>=3.0",
+    "black>=23.0",
+    "ruff>=0.1.0",
+    "mypy>=1.0",
+]
+
+[tool.black]
+line-length = 100
+target-version = ["py39", "py310", "py311", "py312"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py39"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I"]
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401"]
+
+[tool.mypy]
+python_version = "3.12"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = false
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "--cov=src/gitdirector --cov-report=term-missing"

gitdirector-0.1.5/src/gitdirector/__init__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+__all__ = ["main"]

gitdirector-0.1.5/src/gitdirector/cli.py

@@ -0,0 +1,405 @@
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from importlib.metadata import version
+from pathlib import Path
+from typing import Optional
+
+import click
+from rich import box
+from rich.console import Console, Group
+from rich.live import Live
+from rich.spinner import Spinner
+from rich.table import Table
+from rich.text import Text
+
+from .manager import RepositoryManager
+from .repo import Repository, RepositoryInfo, RepoStatus
+
+__version__ = version("gitdirector")
+
+console = Console(highlight=False)
+
+_STATUS_COLOR = {
+    RepoStatus.UP_TO_DATE: "green",
+    RepoStatus.BEHIND: "yellow",
+    RepoStatus.AHEAD: "cyan",
+    RepoStatus.DIVERGED: "red",
+    RepoStatus.UNKNOWN: "bright_black",
+}
+
+_STATUS_LABEL = {
+    RepoStatus.UP_TO_DATE: "up to date",
+    RepoStatus.BEHIND: "behind",
+    RepoStatus.AHEAD: "ahead",
+    RepoStatus.DIVERGED: "diverged",
+    RepoStatus.UNKNOWN: "unknown",
+}
+
+
+def _status_text(status: RepoStatus) -> Text:
+    color = _STATUS_COLOR.get(status, "white")
+    label = _STATUS_LABEL.get(status, status.value)
+    return Text(label, style=color)
+
+
+def _format_size(size: Optional[int]) -> Text:
+    if size is None:
+        return Text("—", style="bright_black")
+    for unit, threshold in (("GB", 1 << 30), ("MB", 1 << 20), ("KB", 1 << 10)):
+        if size >= threshold:
+            return Text(f"{size / threshold:.1f} {unit}", style="dim")
+    return Text(f"{size} B", style="dim")
+
+
+def _changes_text(staged: bool, unstaged: bool) -> Text:
+    if staged and unstaged:
+        return Text("staged+unstaged", style="yellow")
+    elif staged:
+        return Text("staged", style="cyan")
+    elif unstaged:
+        return Text("unstaged", style="yellow")
+    return Text("—", style="bright_black")
+
+
+def _path_text(path: str) -> Text:
+    col_width = max(10, console.width * 2 // 9 - 6)
+    if len(path) > col_width:
+        path = "\u2026" + path[-(col_width - 1) :]
+    return Text(path, justify="right")
+
+
+def _build_repo_table(results: list) -> Table:
+    table = _repo_table()
+    for info in sorted(results, key=lambda r: r.name.lower()):
+        table.add_row(
+            info.name,
+            _status_text(info.status),
+            info.branch or "—",
+            _changes_text(info.staged, info.unstaged),
+            info.last_updated or "—",
+            _format_size(info.size),
+            _path_text(str(info.path)),
+        )
+    return table
+
+
+def _build_pull_table(results: list) -> tuple[Table, int, int]:
+    table = _pull_table()
+    success_count = 0
+    failed_count = 0
+    for name, ok, msg in sorted(results, key=lambda r: r[0].lower()):
+        if ok:
+            table.add_row(name, Text(msg, style="green"))
+            success_count += 1
+        else:
+            table.add_row(name, Text(msg, style="red"))
+            failed_count += 1
+    return table, success_count, failed_count
+
+
+def _repo_table() -> Table:
+    table = Table(
+        box=box.SIMPLE_HEAD,
+        expand=True,
+        show_header=True,
+        header_style="bold",
+        show_edge=False,
+        padding=(0, 1),
+    )
+    table.add_column("REPOSITORY", ratio=2)
+    table.add_column("SYNC", no_wrap=True, ratio=1)
+    table.add_column("BRANCH", style="dim", no_wrap=True, ratio=1)
+    table.add_column("CHANGES", no_wrap=True, ratio=1)
+    table.add_column("LAST COMMIT", style="dim", no_wrap=True, ratio=1)
+    table.add_column("SIZE", style="dim", no_wrap=True, ratio=1, justify="right")
+    table.add_column("PATH", style="dim", ratio=2, no_wrap=True, justify="right")
+    return table
+
+
+def show_help():
+    console.print()
+    console.print(
+        f" [bold white]GITDIRECTOR[/bold white]  "
+        f"[dim]v{__version__} - Manage multiple git repositories[/dim]\n"
+    )
+
+    console.print(" [dim]Commands[/dim]\n")
+
+    cmd_table = Table(
+        box=None,
+        show_header=False,
+        show_edge=False,
+        padding=(0, 2),
+        expand=False,
+    )
+    cmd_table.add_column("cmd", style="white", no_wrap=True)
+    cmd_table.add_column("desc", style="dim")
+
+    for cmd, desc in [
+        ("add PATH [--discover]", "Add a repository or discover all repos under a path"),
+        ("remove PATH [--discover]", "Remove a repository or all repos under a path"),
+        ("list", "List all tracked repositories"),
+        ("status", "Show status summary and per-repo details"),
+        ("pull", "Pull latest changes for all tracked repositories"),
+        ("help", "Show this help message"),
+    ]:
+        cmd_table.add_row(cmd, desc)
+
+    console.print(cmd_table)
+
+    console.print()
+
+
+class _HelpGroup(click.Group):
+    def format_help(self, ctx, formatter):
+        show_help()
+
+
+@click.group(cls=_HelpGroup, invoke_without_command=True)
+@click.pass_context
+def cli(ctx):
+    if ctx.invoked_subcommand is None:
+        show_help()
+
+
+@cli.command()
+@click.argument("path", type=click.Path(exists=False))
+@click.option("--discover", is_flag=True, help="Recursively discover repositories")
+def add(path: str, discover: bool):
+    manager = RepositoryManager()
+    success, message, repos, skipped = manager.add_repository(Path(path), discover=discover)
+
+    console.print()
+    if success:
+        if discover:
+            console.print(f"  {message}")
+            for repo_path in repos:
+                console.print(f"  [green]+[/green] {repo_path}")
+            for repo_path in skipped:
+                console.print(
+                    f"  [dim yellow]\\[skipped][/dim yellow] "
+                    f"[bright_black]{repo_path}[/bright_black]"
+                )
+        else:
+            console.print(f"  [green]+[/green] {message}")
+    else:
+        console.print(f"  [red]{message}[/red]")
+        console.print()
+        raise SystemExit(1)
+    console.print()
+
+
+@cli.command()
+@click.argument("path", type=click.Path(exists=False))
+@click.option("--discover", is_flag=True, help="Recursively discover repositories to remove")
+def remove(path: str, discover: bool):
+    manager = RepositoryManager()
+    success, message, repos = manager.remove_repository(Path(path), discover=discover)
+
+    console.print()
+    if success:
+        console.print(f"  {message}")
+        if repos:
+            for repo_path in repos:
+                console.print(f"  [yellow]-[/yellow] {repo_path}")
+    else:
+        console.print(f"  [red]{message}[/red]")
+        console.print()
+        raise SystemExit(1)
+    console.print()
+
+
+@cli.command(name="list")
+def list_repos():
+    manager = RepositoryManager()
+    paths = sorted(manager.config.repositories, key=lambda p: p.name.lower())
+
+    console.print()
+    if not paths:
+        console.print("  [dim]No repositories tracked[/dim]\n")
+        return
+
+    with Live(console=console, refresh_per_second=12, transient=False) as live:
+        with ThreadPoolExecutor(max_workers=manager.config.max_workers) as executor:
+            futures = {executor.submit(manager.get_repository_status, path): path for path in paths}
+            remaining = len(futures)
+            live.update(
+                Group(
+                    _repo_table(),
+                    Spinner("dots", text=f"  [dim]checking {remaining} repositories...[/dim]"),
+                )
+            )
+            results = []
+            for future in as_completed(futures):
+                remaining -= 1
+                results.append(future.result())
+                table = _build_repo_table(results)
+                if remaining > 0:
+                    live.update(
+                        Group(table, Spinner("dots", text=f"  [dim]{remaining} remaining...[/dim]"))
+                    )
+                else:
+                    live.update(table)
+
+    console.print()
+    total = len(paths)
+    noun = "repository" if total == 1 else "repositories"
+    console.print(f" [green]{total} {noun}[/green]\n")
+
+
+def _build_dirty_display(results: list[RepositoryInfo]) -> Text:
+    dirty_repos = sorted(
+        [r for r in results if r.staged or r.unstaged], key=lambda r: r.name.lower()
+    )
+    output = Text()
+    for repo in dirty_repos:
+        output.append(f"  {repo.name}", style="bold white")
+        output.append(f"  {repo.branch or '—'}\n", style="dim")
+        if repo.staged_files:
+            for f in repo.staged_files:
+                output.append("    ")
+                output.append("staged:", style="cyan")
+                output.append(f"   {f}\n")
+        if repo.unstaged_files:
+            for f in repo.unstaged_files:
+                output.append("    ")
+                output.append("unstaged:", style="yellow")
+                output.append(f" {f}\n")
+        output.append("\n")
+    return output
+
+
+@cli.command()
+def status():
+    manager = RepositoryManager()
+    paths = sorted(manager.config.repositories, key=lambda p: p.name.lower())
+
+    console.print()
+    if not paths:
+        console.print("  [dim]No repositories tracked[/dim]\n")
+        return
+
+    results = []
+    with Live(console=console, refresh_per_second=12, transient=False) as live:
+        with ThreadPoolExecutor(max_workers=manager.config.max_workers) as executor:
+            futures = {executor.submit(manager.get_repository_status, path): path for path in paths}
+            remaining = len(futures)
+            live.update(Spinner("dots", text=f"  [dim]checking {remaining} repositories...[/dim]"))
+            for future in as_completed(futures):
+                remaining -= 1
+                results.append(future.result())
+                display = _build_dirty_display(results)
+                if remaining > 0:
+                    live.update(
+                        Group(
+                            display, Spinner("dots", text=f"  [dim]{remaining} remaining...[/dim]")
+                        )
+                    )
+                else:
+                    live.update(display)
+
+    total = len(results)
+    dirty = sum(1 for r in results if r.staged or r.unstaged)
+    clean = total - dirty
+
+    if not dirty:
+        console.print("  [dim]All repositories are clean[/dim]")
+        console.print()
+
+    summary = Text(" ")
+    summary.append(str(total), style="bold white")
+    summary.append(" repositories", style="dim")
+    summary.append("    ")
+    summary.append(f"{clean} clean", style="green")
+    if dirty:
+        summary.append(f"    {dirty} changed", style="yellow")
+
+    console.print(summary)
+    console.print()
+
+
+def _pull_table() -> Table:
+    table = Table(
+        box=box.SIMPLE_HEAD,
+        expand=True,
+        show_header=True,
+        header_style="bold",
+        show_edge=False,
+        padding=(0, 1),
+    )
+    table.add_column("REPOSITORY", ratio=3)
+    table.add_column("RESULT", ratio=6)
+    return table
+
+
+def _pull_one(path: Path) -> tuple[str, bool, str]:
+    name = path.name
+    if not path.exists() or not (path / ".git").is_dir():
+        return name, False, "path not found"
+    try:
+        repo = Repository(path)
+        ok, msg = repo.pull()
+        return name, ok, msg
+    except Exception as e:
+        return name, False, str(e)
+
+
+@cli.command()
+def pull():
+    manager = RepositoryManager()
+    paths = sorted(manager.config.repositories, key=lambda p: p.name.lower())
+
+    console.print()
+    if not paths:
+        console.print("  [dim]No repositories tracked[/dim]\n")
+        return
+
+    failed_count = 0
+    success_count = 0
+
+    with Live(console=console, refresh_per_second=12, transient=False) as live:
+        with ThreadPoolExecutor(max_workers=manager.config.max_workers) as executor:
+            futures = {executor.submit(_pull_one, path): path for path in paths}
+            remaining = len(futures)
+            live.update(
+                Group(
+                    _pull_table(),
+                    Spinner("dots", text=f"  [dim]pulling {remaining} repositories...[/dim]"),
+                )
+            )
+            results = []
+            for future in as_completed(futures):
+                remaining -= 1
+                results.append(future.result())
+                table, success_count, failed_count = _build_pull_table(results)
+                if remaining > 0:
+                    live.update(
+                        Group(table, Spinner("dots", text=f"  [dim]{remaining} remaining...[/dim]"))
+                    )
+                else:
+                    live.update(table)
+
+    console.print()
+    if failed_count:
+        noun = "repository" if failed_count == 1 else "repositories"
+        console.print(f" [red]{failed_count} {noun} failed[/red]\n")
+        raise SystemExit(1)
+    else:
+        noun = "repository" if success_count == 1 else "repositories"
+        console.print(f" [green]{success_count} {noun}[/green]\n")
+
+
+@cli.command()
+def help():
+    show_help()
+
+
+def main():
+    try:
+        cli()
+    except Exception as e:
+        console.print(f"\n  [red]Error:[/red] {str(e)}\n")
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

gitdirector-0.1.5/src/gitdirector/config.py

@@ -0,0 +1,54 @@
+from pathlib import Path
+
+import yaml
+
+
+class Config:
+    def __init__(self):
+        self.config_dir = Path.home() / ".gitdirector"
+        self.config_file = self.config_dir / "config.yaml"
+        self._ensure_config_dir()
+        self._load()
+
+    def _ensure_config_dir(self) -> None:
+        self.config_dir.mkdir(exist_ok=True)
+
+    DEFAULT_MAX_WORKERS = 10
+
+    def _load(self) -> None:
+        if self.config_file.exists():
+            with open(self.config_file, "r") as f:
+                data = yaml.safe_load(f) or {}
+                self.repositories = [Path(p) for p in data.get("repositories", [])]
+                self.max_workers = int(data.get("max_workers", self.DEFAULT_MAX_WORKERS))
+        else:
+            self.repositories = []
+            self.max_workers = self.DEFAULT_MAX_WORKERS
+
+    def save(self) -> None:
+        data: dict = {"repositories": [str(p) for p in self.repositories]}
+        if self.max_workers != self.DEFAULT_MAX_WORKERS:
+            data["max_workers"] = self.max_workers
+        with open(self.config_file, "w") as f:
+            yaml.dump(data, f, default_flow_style=False)
+
+    def add_repository(self, path: Path) -> bool:
+        if path not in self.repositories:
+            self.repositories.append(path)
+            self.save()
+            return True
+        return False
+
+    def remove_repository(self, path: Path) -> bool:
+        if path in self.repositories:
+            self.repositories.remove(path)
+            self.save()
+            return True
+        return False
+
+    def has_repository(self, path: Path) -> bool:
+        return path in self.repositories
+
+    def clear(self) -> None:
+        self.repositories = []
+        self.save()

gitdirector-0.1.5/src/gitdirector/manager.py

@@ -0,0 +1,156 @@
+from pathlib import Path
+from typing import List, Tuple
+
+from .config import Config
+from .repo import Repository, RepositoryInfo, RepoStatus
+
+
+class RepositoryManager:
+    def __init__(self):
+        self.config = Config()
+
+    def add_repository(
+        self, path: Path, discover: bool = False
+    ) -> Tuple[bool, str, List[Path], List[Path]]:
+        if discover:
+            return self._discover_and_add(path)
+        else:
+            return self._add_single(path)
+
+    def _add_single(self, path: Path) -> Tuple[bool, str, List[Path], List[Path]]:
+        path = path.resolve()
+
+        if not path.exists():
+            return False, f"Path does not exist: {path}", [], []
+
+        if not path.is_dir():
+            return False, f"Path is not a directory: {path}", [], []
+
+        if not (path / ".git").is_dir():
+            return False, f"Not a git repository: {path}", [], []
+
+        if self.config.has_repository(path):
+            return False, f"Repository already tracked: {path}", [], []
+
+        try:
+            self.config.add_repository(path)
+            return True, f"Added repository: {path}", [path], []
+        except Exception as e:
+            return False, f"Error adding repository: {str(e)}", [], []
+
+    def _discover_and_add(self, root: Path) -> Tuple[bool, str, List[Path], List[Path]]:
+        root = root.resolve()
+
+        if not root.exists():
+            return False, f"Path does not exist: {root}", [], []
+
+        if not root.is_dir():
+            return False, f"Path is not a directory: {root}", [], []
+
+        repos = []
+        skipped = []
+
+        for item in root.rglob(".git"):
+            repo_path = item.parent
+            if self.config.has_repository(repo_path):
+                skipped.append(repo_path)
+                continue
+
+            try:
+                self.config.add_repository(repo_path)
+                repos.append(repo_path)
+            except Exception as _:
+                skipped.append(repo_path)
+
+        if not repos:
+            msg = "No new repositories found" if skipped else "No git repositories found"
+            return False, msg, [], skipped
+
+        msg = (
+            f"Added {len(repos)} repository"
+            if len(repos) == 1
+            else f"Added {len(repos)} repositories"
+        )
+
+        return True, msg, repos, skipped
+
+    def remove_repository(self, path: Path, discover: bool = False) -> Tuple[bool, str, List[Path]]:
+        if discover:
+            return self._discover_and_remove(path)
+        else:
+            return self._remove_single(path)
+
+    def _remove_single(self, path: Path) -> Tuple[bool, str, List[Path]]:
+        path = path.resolve()
+
+        if not self.config.has_repository(path):
+            return False, f"Repository not tracked: {path}", []
+
+        try:
+            self.config.remove_repository(path)
+            return True, f"Removed repository: {path}", [path]
+        except Exception as e:
+            return False, f"Error removing repository: {str(e)}", []
+
+    def _discover_and_remove(self, root: Path) -> Tuple[bool, str, List[Path]]:
+        root = root.resolve()
+
+        repos_to_remove = [r for r in self.config.repositories if r.is_relative_to(root)]
+
+        if not repos_to_remove:
+            return False, f"No tracked repositories found under: {root}", []
+
+        try:
+            for repo_path in repos_to_remove:
+                self.config.remove_repository(repo_path)
+
+            msg = (
+                f"Removed {len(repos_to_remove)} repository"
+                if len(repos_to_remove) == 1
+                else f"Removed {len(repos_to_remove)} repositories"
+            )
+            return True, msg, repos_to_remove
+        except Exception as e:
+            return False, f"Error removing repositories: {str(e)}", []
+
+    def get_repository_status(self, path: Path) -> RepositoryInfo:
+        if path.exists() and (path / ".git").is_dir():
+            try:
+                repo = Repository(path)
+                return repo.get_status()
+            except Exception as e:
+                return RepositoryInfo(path, path.name, RepoStatus.UNKNOWN, None, str(e))
+        return RepositoryInfo(
+            path,
+            path.name,
+            RepoStatus.UNKNOWN,
+            None,
+            "Repository path not found or invalid",
+        )
+
+    def list_repositories(self) -> List[RepositoryInfo]:
+        return [self.get_repository_status(path) for path in self.config.repositories]
+
+    def pull_all(self) -> Tuple[List[str], List[str]]:
+        success = []
+        failed = []
+
+        for path in self.config.repositories:
+            if not path.exists() or not (path / ".git").is_dir():
+                failed.append(f"{path.name}: Path not found or invalid")
+                continue
+
+            try:
+                repo = Repository(path)
+                ok, msg = repo.pull()
+                if ok:
+                    success.append(f"{path.name}: {msg}")
+                else:
+                    failed.append(f"{path.name}: {msg}")
+            except Exception as e:
+                failed.append(f"{path.name}: {str(e)}")
+
+        return success, failed
+
+    def get_repository_count(self) -> int:
+        return len(self.config.repositories)

gitdirector-0.1.5/src/gitdirector/repo.py

@@ -0,0 +1,153 @@
+import subprocess
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+
+
+class RepoStatus(Enum):
+    UP_TO_DATE = "up-to-date"
+    AHEAD = "ahead"
+    BEHIND = "behind"
+    DIVERGED = "diverged"
+    UNKNOWN = "unknown"
+
+
+@dataclass
+class RepositoryInfo:
+    path: Path
+    name: str
+    status: RepoStatus
+    branch: Optional[str] = None
+    message: str = ""
+    staged: bool = False
+    unstaged: bool = False
+    staged_files: Optional[list[str]] = None
+    unstaged_files: Optional[list[str]] = None
+    last_updated: Optional[str] = None
+    size: Optional[int] = None
+
+    def __repr__(self) -> str:
+        return f"{self.name:<30} {self.status.value:<12} {self.branch or 'N/A':<15}"
+
+
+class Repository:
+    def __init__(self, path: Path):
+        if not self._is_git_repo(path):
+            raise ValueError(f"Not a git repository: {path}")
+        self.path = path
+        self.name = path.name
+
+    @staticmethod
+    def _is_git_repo(path: Path) -> bool:
+        return (path / ".git").is_dir()
+
+    def _run_git(self, *args: str, _strip: bool = True) -> tuple[int, str, str]:
+        try:
+            result = subprocess.run(
+                ["git", "-C", str(self.path)] + list(args),
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            stdout = result.stdout.strip() if _strip else result.stdout
+            return result.returncode, stdout, result.stderr.strip()
+        except subprocess.TimeoutExpired:
+            return 1, "", "git command timed out"
+        except FileNotFoundError:
+            return 1, "", "git not found"
+
+    def get_current_branch(self) -> Optional[str]:
+        code, out, _ = self._run_git("rev-parse", "--abbrev-ref", "HEAD")
+        return out if code == 0 else None
+
+    def get_last_commit_date(self) -> Optional[str]:
+        code, out, _ = self._run_git("log", "-1", "--format=%cd", "--date=relative")
+        return out if code == 0 and out else None
+
+    def get_tracked_size(self) -> Optional[int]:
+        """Return total byte size of all tracked files (respects .gitignore)."""
+        code, out, _ = self._run_git("ls-files", "-z", _strip=False)
+        if code != 0 or not out:
+            return None
+        total = 0
+        for filename in out.split("\0"):
+            if not filename:
+                continue
+            try:
+                total += (self.path / filename).stat().st_size
+            except OSError:
+                pass
+        return total
+
+    def get_status(self) -> RepositoryInfo:
+        branch = self.get_current_branch()
+
+        code, out, err = self._run_git("fetch", "--dry-run")
+        if code != 0:
+            return RepositoryInfo(self.path, self.name, RepoStatus.UNKNOWN, branch, err)
+
+        code, ahead_behind, _ = self._run_git("rev-list", "--left-right", "--count", "@{u}...HEAD")
+
+        if code != 0:
+            return RepositoryInfo(
+                self.path, self.name, RepoStatus.UNKNOWN, branch, "No tracking branch"
+            )
+
+        try:
+            behind, ahead = map(int, ahead_behind.split())
+            if ahead > 0 and behind > 0:
+                status = RepoStatus.DIVERGED
+                msg = f"ahead {ahead}, behind {behind}"
+            elif ahead > 0:
+                status = RepoStatus.AHEAD
+                msg = f"ahead {ahead}"
+            elif behind > 0:
+                status = RepoStatus.BEHIND
+                msg = f"behind {behind}"
+            else:
+                status = RepoStatus.UP_TO_DATE
+                msg = ""
+        except ValueError:
+            status = RepoStatus.UNKNOWN
+            msg = "Could not parse git status"
+
+        code, porcelain, _ = self._run_git("status", "--porcelain", _strip=False)
+        staged = False
+        unstaged = False
+        staged_files: list[str] = []
+        unstaged_files: list[str] = []
+        if code == 0 and porcelain:
+            for line in porcelain.splitlines():
+                if len(line) >= 2:
+                    x, y = line[0], line[1]
+                    filename = line[3:].strip()
+                    if x not in (" ", "?"):
+                        staged = True
+                        staged_files.append(filename)
+                    if y not in (" ", "?"):
+                        unstaged = True
+                        unstaged_files.append(filename)
+
+        last_updated = self.get_last_commit_date()
+        size = self.get_tracked_size()
+
+        return RepositoryInfo(
+            self.path,
+            self.name,
+            status,
+            branch,
+            msg,
+            staged,
+            unstaged,
+            staged_files or None,
+            unstaged_files or None,
+            last_updated,
+            size,
+        )
+
+    def pull(self) -> tuple[bool, str]:
+        code, out, err = self._run_git("pull", "--ff-only")
+        if code == 0:
+            return True, out
+        return False, err