repowatch 0.4.0__py3-none-any.whl

repowatch/tui.py

@@ -0,0 +1,402 @@
+"""Textual front end: one row per repo, one column per remote label."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from rich.text import Text
+from textual import work
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Button, DataTable, Footer, Header, Input, Label, Static
+
+from . import core
+from . import sync as syncmod
+from .config import Config
+from .render import branch_cell, flags_cell, local_cell, remote_cell, sync_text
+
+LEGEND = (
+    "[green]=[/] in sync   [magenta]↑n[/] local ahead (push)   [yellow]↓n[/] remote ahead (pull)   "
+    "[bold red]↑↓[/] diverged   [cyan]cyan[/] mirror lagging   [dim]—[/] not on remote   [red dim]✗[/] fetch failed   "
+    "local: [green]+[/]staged [yellow]~[/]modified [dim yellow]?[/]untracked [cyan]$[/]stash"
+)
+
+
+class AddRemoteScreen(ModalScreen[tuple[str, str] | None]):
+    DEFAULT_CSS = """
+    AddRemoteScreen { align: center middle; }
+    #dialog { width: 80; height: auto; border: thick $accent; padding: 1 2; background: $surface; }
+    #dialog Input { margin-bottom: 1; }
+    #buttons { height: auto; align-horizontal: right; }
+    #buttons Button { margin-left: 1; }
+    """
+    BINDINGS = [Binding("escape", "cancel", "Cancel")]
+
+    def __init__(self, repo_name: str, name: str, url: str) -> None:
+        super().__init__()
+        self.repo_name, self.default_name, self.default_url = repo_name, name, url
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="dialog"):
+            yield Label(f"Add remote to [b]{self.repo_name}[/b]")
+            yield Input(value=self.default_name, placeholder="remote name, e.g. gitea", id="rname")
+            yield Input(value=self.default_url, placeholder="URL", id="rurl")
+            with Horizontal(id="buttons"):
+                yield Button("Cancel", id="cancel")
+                yield Button("Add & fetch", variant="primary", id="ok")
+
+    def on_mount(self) -> None:
+        self.query_one("#rurl" if self.default_name else "#rname", Input).focus()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "ok":
+            self._submit()
+        else:
+            self.dismiss(None)
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        self._submit()
+
+    def _submit(self) -> None:
+        name = self.query_one("#rname", Input).value.strip()
+        url = self.query_one("#rurl", Input).value.strip()
+        if name and url:
+            self.dismiss((name, url))
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+
+class SyncScreen(ModalScreen[bool]):
+    """Shows the dry-run plan; Apply returns True."""
+    DEFAULT_CSS = """
+    SyncScreen { align: center middle; }
+    #sdialog { width: 110; max-width: 95%; height: auto; max-height: 85%; border: thick $accent;
+               padding: 1 2; background: $surface; }
+    #splan { height: auto; max-height: 30; margin: 1 0; }
+    #sbuttons { height: auto; align-horizontal: right; }
+    #sbuttons Button { margin-left: 1; }
+    """
+    BINDINGS = [Binding("escape", "cancel", "Cancel"), Binding("y", "apply", "Apply")]
+
+    def __init__(self, plan: Text, can_apply: bool) -> None:
+        super().__init__()
+        self.plan, self.can_apply = plan, can_apply
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="sdialog"):
+            yield Label("[b]Sync plan[/b] — fast-forward only, nothing is force-pushed")
+            with VerticalScroll(id="splan"):
+                yield Static(self.plan)
+            with Horizontal(id="sbuttons"):
+                yield Button("Close" if not self.can_apply else "Cancel", id="cancel")
+                if self.can_apply:
+                    yield Button("Apply (y)", variant="primary", id="apply")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        self.dismiss(event.button.id == "apply")
+
+    def action_apply(self) -> None:
+        if self.can_apply:
+            self.dismiss(True)
+
+    def action_cancel(self) -> None:
+        self.dismiss(False)
+
+
+class RepoWatch(App):
+    TITLE = "repowatch"
+    CSS = """
+    DataTable { height: 1fr; }
+    #detail { height: auto; max-height: 14; border: round $primary-darken-2; padding: 0 1; }
+    #legend { height: auto; color: $text-muted; padding: 0 1; }
+    """
+    BINDINGS = [
+        Binding("r", "rescan", "Rescan"),
+        Binding("f", "fetch_one", "Fetch"),
+        Binding("F", "fetch_all", "Fetch all"),
+        Binding("s", "sync_one", "Sync"),
+        Binding("S", "sync_all", "Sync all"),
+        Binding("a", "add_remote", "Add remote"),
+        Binding("o", "open_folder", "Open folder"),
+        Binding("d", "toggle_dirty", "Only attention"),
+        Binding("q", "quit", "Quit"),
+    ]
+
+    def __init__(self, root: Path, cfg: Config, fetch_on_start: bool = False) -> None:
+        super().__init__()
+        self.root, self.cfg, self.fetch_on_start = root, cfg, fetch_on_start
+        self.statuses: dict[str, core.RepoStatus] = {}
+        self.order: list[str] = []
+        self.fetch_errors: dict[str, dict[str, str]] = {}
+        self.attention_only = False
+        self.busy: set[str] = set()
+
+    # ------------------------------------------------------------------ layout
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield DataTable(id="table", cursor_type="row", zebra_stripes=True)
+        yield Static(id="detail")
+        yield Static(LEGEND, id="legend")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.sub_title = str(self.root)
+        if self.fetch_on_start:
+            self.action_fetch_all()
+        else:
+            self.action_rescan()
+        if self.cfg.refresh_seconds > 0:
+            self.set_interval(self.cfg.refresh_seconds, self._auto_refresh)
+
+    # ------------------------------------------------------------------- table
+
+    def _visible(self) -> list[str]:
+        if not self.attention_only:
+            return self.order
+        return [p for p in self.order if self.statuses[p].flags()]
+
+    def _render_table(self) -> None:
+        table = self.query_one(DataTable)
+        cursor_key = self._selected_path()
+        table.clear(columns=True)
+        labels = core.all_labels(list(self.statuses.values()), self.cfg.column_order)
+        table.add_column("Repo", key="repo")
+        table.add_column("Branch", key="branch")
+        table.add_column("Local", key="local")
+        for lab in labels:
+            table.add_column(lab, key=f"r:{lab}")
+        table.add_column("Status", key="flags")
+
+        rows = self._visible()
+        for p in rows:
+            s = self.statuses[p]
+            name = Text(s.name)
+            if p in self.busy:
+                name.append(" ⟳", style="cyan")
+            cells = [name, branch_cell(s), local_cell(s)]
+            cells += [remote_cell(s.remote(lab)) for lab in labels]
+            cells.append(flags_cell(s))
+            table.add_row(*cells, key=p)
+
+        if cursor_key in rows:
+            table.move_cursor(row=rows.index(cursor_key))
+        self._render_detail()
+        n_att = sum(1 for p in self.order if self.statuses[p].flags())
+        self.sub_title = f"{self.root}  ·  {len(self.order)} repos, {n_att} need attention" + (
+            "  ·  filtered" if self.attention_only else "")
+
+    def _selected_path(self) -> str | None:
+        table = self.query_one(DataTable)
+        if table.row_count == 0:
+            return None
+        try:
+            return table.coordinate_to_cell_key(table.cursor_coordinate).row_key.value
+        except Exception:
+            return None
+
+    def _render_detail(self) -> None:
+        detail = self.query_one("#detail", Static)
+        p = self._selected_path()
+        if not p or p not in self.statuses:
+            detail.update("No repos found." if not self.order else "")
+            return
+        s = self.statuses[p]
+        t = Text()
+        t.append(s.name, style="bold")
+        t.append(f"   {s.path}\n", style="dim")
+        if s.error:
+            t.append(f"Error: {s.error}\n", style="red")
+        br = "(detached)" if s.detached else (s.branch or "?")
+        t.append(f"Branch {br}")
+        t.append(f" → {s.upstream}" if s.upstream else "  (no upstream)", style="dim")
+        t.append(f"   ·   last fetch {core.ago(s.last_fetch)}\n", style="dim")
+        for r in s.remotes:
+            t.append(f"  {r.label:<10}", style="bold")
+            t.append(f"{r.name:<10}", style="dim")
+            t.append_text(remote_cell(r))
+            t.append(f"   {r.url}", style="dim")
+            if r.state == "missing":
+                t.append(f"   (no {s.branch or 'HEAD'} on this remote)", style="dim")
+            if r.error:
+                t.append(f"\n              {r.error}", style="red dim")
+            t.append("\n")
+        tips = {}
+        for r in s.remotes:
+            if r.sha:
+                tips.setdefault(r.sha, []).append(r.label)
+        if len(tips) > 1:
+            t.append("Remotes disagree: ", style="bold cyan")
+            t.append("  vs  ".join(f"{'/'.join(v)} @ {k[:7]}" for k, v in tips.items()))
+        detail.update(t)
+
+    def on_data_table_row_highlighted(self, _event: DataTable.RowHighlighted) -> None:
+        self._render_detail()
+
+    # ----------------------------------------------------------------- workers
+
+    @work(thread=True, exclusive=True, group="scan")
+    def action_rescan(self) -> None:
+        statuses = core.scan(self.root, self.cfg, fetch_errors=self.fetch_errors)
+        self.call_from_thread(self._apply_scan, statuses)
+
+    def _apply_scan(self, statuses: list[core.RepoStatus]) -> None:
+        self.statuses = {s.path: s for s in statuses}
+        self.order = [s.path for s in statuses]
+        self._render_table()
+
+    def _auto_refresh(self) -> None:
+        if not self.busy:
+            self.action_rescan()
+
+    def _refresh_one(self, p: str) -> None:
+        s = core.repo_status(Path(p), self.root, self.cfg, self.fetch_errors.get(p))
+        self.call_from_thread(self._apply_one, s)
+
+    def _apply_one(self, s: core.RepoStatus) -> None:
+        self.busy.discard(s.path)
+        if s.path not in self.statuses:
+            self.order.append(s.path)
+        self.statuses[s.path] = s
+        self._render_table()
+
+    def _mark_busy(self, paths: list[str]) -> None:
+        self.busy.update(paths)
+        self._render_table()
+
+    @work(thread=True, group="fetch")
+    def _fetch_paths(self, paths: list[str]) -> None:
+        from concurrent.futures import ThreadPoolExecutor
+
+        def one(p: str) -> None:
+            self.fetch_errors[p] = core.fetch_repo(p, self.cfg.fetch_timeout)
+            self._refresh_one(p)
+
+        with ThreadPoolExecutor(max_workers=6) as pool:
+            list(pool.map(one, paths))
+        self.call_from_thread(self.notify, f"Fetched {len(paths)} repo(s)", timeout=3)
+
+    # ----------------------------------------------------------------- actions
+
+    def action_fetch_one(self) -> None:
+        p = self._selected_path()
+        if p:
+            self._mark_busy([p])
+            self._fetch_paths([p])
+
+    def action_fetch_all(self) -> None:
+        if not self.order:
+            # first run with --fetch: discover, then fetch everything
+            repos = [str(p) for p in core.find_repos(self.root, self.cfg.depth)]
+            self.order = repos
+            self.statuses = {p: core.RepoStatus(path=p, name=Path(p).name) for p in repos}
+        self._mark_busy(list(self.order))
+        self._fetch_paths(list(self.order))
+
+    # -------------------------------------------------------------------- sync
+
+    def action_sync_one(self) -> None:
+        p = self._selected_path()
+        if p:
+            self._mark_busy([p])
+            self._sync_plan([p])
+
+    def action_sync_all(self) -> None:
+        if self.order:
+            self._mark_busy(list(self.order))
+            self._sync_plan(list(self.order))
+
+    @work(thread=True, exclusive=True, group="sync")
+    def _sync_plan(self, paths: list[str]) -> None:
+        from concurrent.futures import ThreadPoolExecutor
+
+        root = str(self.root)
+        with ThreadPoolExecutor(max_workers=6) as pool:
+            results = list(pool.map(lambda p: syncmod.plan_and_run(p, root, self.cfg, apply=False), paths))
+        # fetch happened as part of planning: refresh rows now
+        for p in paths:
+            self._refresh_one(p)
+        text = Text()
+        for r in results:
+            if len(results) > 1 and not r.steps and not r.skipped:
+                continue
+            text.append_text(sync_text(r, applied=False))
+        if not text.plain:
+            text = Text("Everything is in step.", style="green")
+        can_apply = any(r.actions for r in results)
+        to_apply = [r.path for r in results if r.actions]
+
+        def done(ok: bool | None) -> None:
+            if ok:
+                self._mark_busy(to_apply)
+                self._sync_apply(to_apply)
+
+        self.call_from_thread(self.push_screen, SyncScreen(text, can_apply), done)
+
+    @work(thread=True, group="sync")
+    def _sync_apply(self, paths: list[str]) -> None:
+        root = str(self.root)
+        failed = 0
+        for p in paths:
+            r = syncmod.plan_and_run(p, root, self.cfg, apply=True, fetch=False)
+            failed += len(r.failed)
+            self._refresh_one(p)
+        msg = f"Synced {len(paths)} repo(s)" + (f", {failed} step(s) failed — run sync again to see why" if failed else "")
+        self.call_from_thread(self.notify, msg, severity="error" if failed else "information", timeout=5)
+
+    def action_toggle_dirty(self) -> None:
+        self.attention_only = not self.attention_only
+        self._render_table()
+
+    def action_open_folder(self) -> None:
+        p = self._selected_path()
+        if not p:
+            return
+        try:
+            if sys.platform == "win32":
+                os.startfile(p)  # type: ignore[attr-defined]
+            elif sys.platform == "darwin":
+                subprocess.Popen(["open", p])
+            else:
+                subprocess.Popen(["xdg-open", p])
+        except Exception as exc:
+            self.notify(f"Couldn't open folder: {exc}", severity="error")
+
+    def action_add_remote(self) -> None:
+        p = self._selected_path()
+        if not p:
+            return
+        s = self.statuses[p]
+        existing = {r.label for r in s.remotes} | {r.name for r in s.remotes}
+        name, url = "", ""
+        owner_repo = next((core.url_owner_repo(r.url) for r in s.remotes if core.url_owner_repo(r.url)), None)
+        for tname, tmpl in self.cfg.remote_templates.items():
+            if tname not in existing:
+                name = tname
+                if owner_repo:
+                    url = tmpl.format(owner=owner_repo[0], repo=owner_repo[1])
+                break
+
+        def done(result: tuple[str, str] | None) -> None:
+            if not result:
+                return
+            rname, rurl = result
+            err = core.add_remote(p, rname, rurl)
+            if err:
+                self.notify(err, severity="error")
+                return
+            self.notify(f"Added remote {rname}", timeout=3)
+            self._mark_busy([p])
+            self._fetch_paths([p])
+
+        self.push_screen(AddRemoteScreen(s.name, name, url), done)
+
+
+def run(root: Path, cfg: Config, fetch: bool = False) -> None:
+    RepoWatch(root, cfg, fetch_on_start=fetch).run()

repowatch-0.4.0.dist-info/METADATA

@@ -0,0 +1,218 @@
+Metadata-Version: 2.4
+Name: repowatch
+Version: 0.4.0
+Summary: Every git repo under a folder, compared across all its remotes, with fast-forward-only sync and safe branch pruning.
+Author: Mark Wharry
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/markgwharry/repowatch
+Project-URL: Issues, https://github.com/markgwharry/repowatch/issues
+Project-URL: Changelog, https://github.com/markgwharry/repowatch/blob/main/CHANGELOG.md
+Keywords: git,multi-repo,remotes,mirror,gitea,github,tui,textual
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: textual>=0.80
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Dynamic: license-file
+
+# repowatch
+
+[![CI](https://github.com/markgwharry/repowatch/actions/workflows/ci.yml/badge.svg)](https://github.com/markgwharry/repowatch/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/repowatch)](https://pypi.org/project/repowatch/)
+[![Python](https://img.shields.io/pypi/pyversions/repowatch)](https://pypi.org/project/repowatch/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
+
+**Every git repo under a folder, compared across all of its remotes.**
+
+Point repowatch at your code folder. It finds every repo, then shows one row per repo with a column per remote, so you can see at a glance where each copy stands: local, GitHub, a self-hosted Gitea, a backup.
+
+![repowatch TUI](docs/screenshot.png)
+
+It's built for people who keep the same code in more than one place, for example GitHub plus a work or home Gitea, or one machine at work and another at home. It answers three questions:
+
+1. **Where does everything stand?** A matrix of every repo against every remote.
+2. **Can it level them for me, safely?** `sync` fast-forwards your secondary remote and your local checkout to match the primary, in both directions. It never force-pushes or merges.
+3. **What's all this branch clutter?** `prune` deletes branches whose work is already in `main`, including squash-merged ones, and explains every branch it keeps.
+
+## Install
+
+Requires Python 3.11+ and `git` on your PATH.
+
+```bash
+pipx install repowatch        # or: uv tool install repowatch
+```
+
+From source:
+
+```bash
+git clone https://github.com/markgwharry/repowatch && cd repowatch
+pipx install .
+```
+
+> On Windows, use Windows Terminal, which is the default on Windows 11. The legacy console mangles the arrows. In Git Bash, write paths with forward slashes (`./repowatch`), because backslashes get eaten.
+
+## Quick start
+
+```bash
+repowatch ~/code                     # interactive matrix
+repowatch ~/code --fetch             # fetch every remote first
+repowatch status ~/code              # print the matrix once
+repowatch status ~/code --json       # machine-readable, for scripts and dashboards
+repowatch init                       # write a commented config file
+```
+
+Set `root` in the config and plain `repowatch` opens your code folder.
+
+## Reading the matrix
+
+```
+Repo             Branch  Local            github         gitea        Status
+core-lib         main    965f254 ✓        965f254 =      965f254 =    ok
+cli-tool         main    e5c17be ✓        f4a93cd ↑2     f4a93cd ↑2   push
+ticker           main    5cd32d9 ✓        5cd32d9 =      e88d620 ↑1   mirror lag
+work/tracker     main    577c22d ✓        5296d38 ↓1     577c22d =    pull mirror lag
+work/analysis    main    fe0af99 ~1 ?1 $1 883a7b7 ↑1 ↓1  c458ab1 ↑1   dirty untracked stash diverged
+```
+
+Each remote cell shows that remote's tip of your current branch, and how your local HEAD compares with it:
+
+| Symbol | Meaning |
+|---|---|
+| `=` | Same commit |
+| `↑n` | Local has n commits the remote doesn't (push) |
+| `↓n` | Remote has n commits local doesn't (pull) |
+| `↑n ↓m` | Diverged |
+| `—` | Branch doesn't exist on that remote |
+| `✗` | Last fetch failed (offline, VPN down, auth) |
+| cyan | A mirror remote is lagging. Expected; `sync` deals with it |
+
+**Local** shows HEAD plus `+` staged, `~` modified, `?` untracked, `!` conflicts and `$` stashes, or `✓` when clean.
+
+**Columns are labelled by host, not remote name.** `origin → github.com` and `upstream → github.com` both appear under `github`. Map your own hosts in the config.
+
+### TUI keys
+
+| Key | Action |
+|---|---|
+| `r` | Rescan (local only, fast) |
+| `f` / `F` | Fetch the selected repo / all repos |
+| `s` / `S` | Sync the selected repo / all repos: shows the plan first, `y` applies it |
+| `a` | Add a remote (pre-filled from a template) |
+| `o` | Open the folder |
+| `d` | Show only repos that need attention |
+| `q` | Quit |
+
+## Sync
+
+Keeps a **secondary** remote (e.g. Gitea) and your local checkout level with a **primary** remote (e.g. GitHub).
+
+```bash
+repowatch sync                      # dry run: the plan, nothing changed
+repowatch sync --apply
+repowatch sync --apply --repo my-service --repo docs
+```
+
+Everything is **fast-forward only**:
+
+| Situation | What sync does |
+|---|---|
+| Primary ahead of secondary | Pushes primary's tip to secondary |
+| Branch only on primary | Creates it on secondary |
+| Secondary ahead of primary | Pushes secondary's tip to primary, so work done on the secondary flows up |
+| Primary and secondary diverged | Flags it and touches nothing |
+| Branch only on secondary | Flags it: could be new there, or deleted on primary |
+| Local checkout behind and clean | Fast-forwards it |
+| Local dirty, detached or diverged | Leaves it alone and flags it |
+| Local has unpushed commits | Flags it. Pushing your own work stays your decision |
+
+By default only `main`/`master` are synced and `dependabot/*` is skipped. Change `sync_branches` and `sync_exclude` (glob lists) in the config.
+
+A protected branch on the primary rejects a secondary-ahead push. That's reported as a failed step and nothing else is affected. Unattended runs over SSH need a key without a passphrase, or a running agent; otherwise that remote shows as unreachable and is skipped.
+
+### Run sync on a schedule
+
+```bash
+repowatch schedule              # hourly via Windows Task Scheduler (silent, via pythonw)
+repowatch schedule --every 30
+repowatch schedule --remove
+```
+
+Output goes to `sync.log` in the config folder and rotates at 1 MB. On macOS and Linux, `schedule` prints a crontab line for you to add.
+
+## Prune
+
+Deletes stale branches on the primary remote.
+
+```bash
+repowatch prune                          # dry run: what goes, and why the rest stay
+repowatch prune --apply
+repowatch prune --include-unmerged 180   # also abandoned branches, >180 days old, with no open PR
+repowatch prune -v                       # also list merged branches it keeps
+```
+
+| Kind | Meaning | Default |
+|---|---|---|
+| **merged** | Tip already in the default branch (merge, fast-forward or rebase) | Deleted |
+| **squash-merged** | Its combined change is already in the default branch as one commit | Deleted |
+| **unmerged** | Has commits the default branch doesn't | Kept and listed |
+
+It never deletes the default branch, anything matching `prune_keep` (default `main`, `master`, `develop`, `release/*`), anything younger than `prune_min_age_days` (default 7), or the branch you have checked out. Unmerged branches are only deleted with `--include-unmerged`, and only after the GitHub CLI (`gh`) confirms they have no open PR. Without `gh`, they're never touched. Deletions are verified against the remote afterwards.
+
+To stop branches piling up again: `gh repo edit OWNER/REPO --delete-branch-on-merge`.
+
+## Configuration
+
+`repowatch init` writes a commented file to:
+
+- Windows: `%APPDATA%\repowatch\config.toml`
+- macOS / Linux: `~/.config/repowatch/config.toml`, or `$XDG_CONFIG_HOME/repowatch/config.toml`
+
+```toml
+root = "~/code"
+depth = 3                            # folder levels to search
+refresh_seconds = 30                 # TUI local auto-refresh; 0 = off
+fetch_timeout = 25                   # seconds, per remote
+column_order = ["github", "gitea"]
+primary_labels = ["github"]          # sync's source of truth; prune's target
+mirror_labels = ["gitea"]            # kept level by sync; lag shown as "mirror lag"
+sync_branches = ["main", "master"]
+sync_exclude = ["dependabot/*"]
+prune_keep = ["main", "master", "develop", "release/*"]
+prune_min_age_days = 7
+
+[hosts]                              # host -> column label (exact match, then substring)
+"git.example.internal" = "gitea"
+"192.168.1.20" = "gitea"
+
+[remote_templates]                   # pre-fills the TUI's add-remote dialog
+gitea = "https://git.example.internal/{owner}/{repo}.git"
+```
+
+Use `repowatch --config other.toml …` to point at a different file.
+
+## How it behaves
+
+- **Remote columns are only as fresh as your last fetch.** `r` and the auto-refresh are local-only; `f`, `F`, `--fetch`, `sync` and `prune` go to the network.
+- **It never prompts.** Terminal prompts, credential-manager pop-ups and interactive SSH are disabled. A remote that needs input shows `✗` and the reason, rather than hanging. Cached credentials (credential managers, keychain, ssh-agent) work normally.
+- **Each remote is fetched separately, with a timeout**, so an unreachable Gitea doesn't hold up GitHub.
+- **Discovery stops at the first `.git`.** It doesn't descend into repos, and it skips `node_modules`, `.venv`, `build` and similar.
+- **Don't keep repos in a cloud-synced folder** (OneDrive, Dropbox, iCloud). Sync clients lock and duplicate files inside `.git`. Your remotes are the backup.
+
+## Contributing
+
+Issues and PRs are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md). The test suite builds throwaway repos with GitHub- and Gitea-style remotes for every state repowatch distinguishes, and runs on Windows, macOS and Linux.
+
+## Licence
+
+[MIT](LICENSE)

repowatch-0.4.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+repowatch/__init__.py,sha256=oYSrpQkvTDLB_2IXjv12tH8g_QaKYXa_D4Yv-0MABZs,119
+repowatch/__main__.py,sha256=E6Gls0DNz8GQK2K-kOUIx8cYhgANW_CH54VKrfCfs14,52
+repowatch/cli.py,sha256=C9flBBgd9Qu4z4IdusCNrMBuTKUszlfEkARXwslGx9w,11914
+repowatch/config.py,sha256=oW-lwsb03d5OBcHa8SaPniGlPpRMCuJcVgttsLDoLd8,4640
+repowatch/core.py,sha256=yl9komOMeGnTpF91rYWHVhCumUc5LsdVNRz2lhRs50Y,13526
+repowatch/prune.py,sha256=cuBBqvKN0R7q98qU-IhXaVkLdE_kEyaCGsYwiWPh92c,8555
+repowatch/render.py,sha256=8WJYVXD79umgpED9qx_c_HqgeiBvSAoR3nJa9VT1qPg,3507
+repowatch/sync.py,sha256=GdWrmX-zUutGvu_8_nq5tJQrZBpkTONHwtUvH61NIyw,7680
+repowatch/tui.py,sha256=mbqr8alcLNfNBG-NERlb4ebpVAOmK0x6UORUaEATNx8,15582
+repowatch-0.4.0.dist-info/licenses/LICENSE,sha256=N4SrDhXetPRq2cjEoF2owkvhXogz3yXqSb4-IJX0JiE,1068
+repowatch-0.4.0.dist-info/METADATA,sha256=lq84VRjP1vhhEK1lqF4YVjo6bTeQlUF35B-u9U6NQ-M,10213
+repowatch-0.4.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+repowatch-0.4.0.dist-info/entry_points.txt,sha256=DcD6_sK-7cFH4Cg1ThdjlkyJA53_M2eThHPUvG109bY,49
+repowatch-0.4.0.dist-info/top_level.txt,sha256=DBkkpdnOvG7PH2Teb_9CxGXAAS_XIjtO0GXoSnUPf08,10
+repowatch-0.4.0.dist-info/RECORD,,

repowatch-0.4.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
+

repowatch-0.4.0.dist-info/entry_points.txt

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

repowatch-0.4.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mark Wharry
+
+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.

repowatch-0.4.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+repowatch