gitstow 0.1.0__py3-none-any.whl

gitstow/cli/stats.py

@@ -0,0 +1,126 @@
+"""gitstow stats — collection statistics."""
+
+from __future__ import annotations
+
+import json
+import sys
+from collections import defaultdict
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from gitstow.core.config import load_config
+from gitstow.core.git import get_disk_size, format_size, is_git_repo
+from gitstow.core.repo import RepoStore
+from gitstow.cli.helpers import iter_repos_with_workspace
+
+console = Console()
+
+
+def stats(
+    ctx: typer.Context,
+    output_json: bool = typer.Option(
+        False, "--json", "-j", help="JSON output.",
+    ),
+) -> None:
+    """[bold]Stats[/bold] — collection statistics and disk usage.
+
+    Shows total repos, owners, tags, frozen count, and disk usage.
+    """
+    settings = load_config()
+    store = RepoStore()
+    ws_label = ctx.obj.get("workspace") if ctx.obj else None
+
+    repo_ws_pairs = iter_repos_with_workspace(store, settings, ws_label)
+    repos = [r for r, _ in repo_ws_pairs]
+    owners = store.all_owners()
+    tags = store.all_tags()
+    frozen = store.list_frozen()
+
+    # Calculate disk usage (can be slow for large repos)
+    total_size = 0
+    size_by_owner: dict[str, int] = defaultdict(int)
+    largest_repos: list[tuple[str, int]] = []
+
+    for repo, ws in repo_ws_pairs:
+        path = repo.get_path(ws.get_path())
+        if path.exists() and is_git_repo(path):
+            size = get_disk_size(path)
+            total_size += size
+            size_by_owner[repo.owner] += size
+            largest_repos.append((repo.key, size))
+
+    largest_repos.sort(key=lambda x: x[1], reverse=True)
+
+    # Find oldest and newest
+    added_dates = [r.added for r in repos if r.added]
+    oldest = min(added_dates) if added_dates else "unknown"
+    newest = max(added_dates) if added_dates else "unknown"
+
+    # Pull activity
+    never_pulled = sum(1 for r in repos if not r.last_pulled)
+
+    data = {
+        "total_repos": len(repos),
+        "total_owners": len(owners),
+        "total_tags": len(tags),
+        "frozen_count": len(frozen),
+        "total_disk_size": total_size,
+        "total_disk_size_human": format_size(total_size),
+        "oldest_added": oldest,
+        "newest_added": newest,
+        "never_pulled": never_pulled,
+        "owners": {k: {"count": v, "size": size_by_owner.get(k, 0), "size_human": format_size(size_by_owner.get(k, 0))} for k, v in owners.items()},
+        "tags": tags,
+        "largest_repos": [{"repo": k, "size": v, "size_human": format_size(v)} for k, v in largest_repos[:10]],
+    }
+
+    if output_json:
+        json.dump(data, sys.stdout, indent=2)
+        print()
+        return
+
+    # Human display
+    console.print("\n  [bold]gitstow stats[/bold]\n")
+
+    # Overview
+    console.print(f"    Repos:       {len(repos)}")
+    console.print(f"    Owners:      {len(owners)}")
+    console.print(f"    Tags:        {len(tags)}")
+    console.print(f"    Frozen:      {len(frozen)}")
+    console.print(f"    Disk usage:  {format_size(total_size)}")
+    console.print(f"    First added: {oldest}")
+    console.print(f"    Last added:  {newest}")
+    if never_pulled:
+        console.print(f"    Never pulled:{never_pulled}")
+
+    # Repos by owner
+    if owners:
+        console.print("\n  [bold]By Owner[/bold]\n")
+        table = Table(show_header=True, header_style="bold", box=None, padding=(0, 2))
+        table.add_column("Owner")
+        table.add_column("Repos", justify="right")
+        table.add_column("Disk", justify="right")
+
+        for owner_name in sorted(owners.keys()):
+            table.add_row(
+                owner_name,
+                str(owners[owner_name]),
+                format_size(size_by_owner.get(owner_name, 0)),
+            )
+        console.print(table)
+
+    # Tags
+    if tags:
+        console.print("\n  [bold]Tags[/bold]\n")
+        for tag_name, count in sorted(tags.items()):
+            console.print(f"    {tag_name}  [dim]({count})[/dim]")
+
+    # Largest repos
+    if largest_repos:
+        console.print("\n  [bold]Largest Repos[/bold]\n")
+        for repo_key, size in largest_repos[:5]:
+            console.print(f"    {repo_key.ljust(30)} {format_size(size)}")
+
+    console.print()

gitstow/cli/status.py

@@ -0,0 +1,213 @@
+"""gitstow status — dashboard showing git status across all repos."""
+
+from __future__ import annotations
+
+import json
+import sys
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from gitstow.core.config import load_config, Workspace
+from gitstow.core.git import get_status, is_git_repo, get_last_commit
+from gitstow.core.repo import Repo, RepoStore
+from gitstow.core.parallel import run_parallel_sync
+from gitstow.cli.helpers import iter_repos_with_workspace
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+def _get_repo_status(repo: Repo, ws: Workspace) -> dict:
+    """Gather status for a single repo."""
+    path = repo.get_path(ws.get_path())
+
+    if not path.exists():
+        return {"repo": repo.key, "workspace": repo.workspace, "error": "Not found on disk"}
+
+    if not is_git_repo(path):
+        return {"repo": repo.key, "workspace": repo.workspace, "error": "Not a git repo"}
+
+    status = get_status(path)
+    commit = get_last_commit(path)
+
+    return {
+        "repo": repo.key,
+        "workspace": repo.workspace,
+        "branch": status.branch,
+        "dirty": status.dirty,
+        "staged": status.staged,
+        "untracked": status.untracked,
+        "ahead": status.ahead,
+        "behind": status.behind,
+        "clean": status.clean,
+        "status_symbol": status.status_symbol,
+        "ahead_behind": status.ahead_behind_str,
+        "frozen": repo.frozen,
+        "tags": repo.tags,
+        "last_commit": commit.message,
+        "last_commit_date": commit.date,
+        "last_pulled": repo.last_pulled,
+    }
+
+
+def status(
+    ctx: typer.Context,
+    tag: Optional[list[str]] = typer.Option(
+        None, "--tag", "-t", help="Filter by tag.",
+    ),
+    owner: Optional[str] = typer.Option(
+        None, "--owner", help="Filter by owner.",
+    ),
+    dirty_only: bool = typer.Option(
+        False, "--dirty", help="Show only dirty repos.",
+    ),
+    output_json: bool = typer.Option(
+        False, "--json", "-j", help="JSON output.",
+    ),
+    quiet: bool = typer.Option(
+        False, "--quiet", "-q", help="Minimal output.",
+    ),
+) -> None:
+    """[bold yellow]Status[/bold yellow] dashboard — git status across all repos.
+
+    Shows branch, clean/dirty state, ahead/behind, and last commit.
+
+    \b
+    Examples:
+      gitstow status                  # All repos
+      gitstow status --dirty          # Only dirty repos
+      gitstow status --tag ai         # Filter by tag
+      gitstow status -w active        # Filter by workspace
+    """
+    settings = load_config()
+    store = RepoStore()
+    ws_label = ctx.obj.get("workspace") if ctx.obj else None
+
+    repo_ws_pairs = iter_repos_with_workspace(store, settings, ws_label)
+
+    if tag:
+        tag_set = set(tag)
+        repo_ws_pairs = [(r, ws) for r, ws in repo_ws_pairs if tag_set.intersection(r.tags)]
+
+    if owner:
+        repo_ws_pairs = [(r, ws) for r, ws in repo_ws_pairs if r.owner == owner]
+
+    if not repo_ws_pairs:
+        if not quiet:
+            console.print("[dim]No repos tracked.[/dim]")
+        return
+
+    # Gather status in parallel
+    tasks = [
+        (repo.global_key, lambda r=repo, w=ws: _get_repo_status(r, w))
+        for repo, ws in repo_ws_pairs
+    ]
+
+    results = run_parallel_sync(tasks, max_concurrent=settings.parallel_limit)
+
+    # Extract result data
+    statuses = []
+    for task_result in results:
+        if task_result.success and task_result.data:
+            statuses.append(task_result.data)
+        else:
+            statuses.append({
+                "repo": task_result.key,
+                "error": task_result.error or "Unknown error",
+            })
+
+    # Filter dirty only
+    if dirty_only:
+        statuses = [s for s in statuses if not s.get("clean", True)]
+
+    if output_json:
+        json.dump(statuses, sys.stdout, indent=2)
+        print()
+        return
+
+    if not statuses:
+        console.print("[dim]No repos match the filter.[/dim]")
+        return
+
+    # Check if multiple workspaces — show workspace column if so
+    ws_labels = {s.get("workspace", "") for s in statuses if "error" not in s or "workspace" in s}
+    multi_ws = len(ws_labels) > 1
+
+    # Rich table
+    console.print(f"\n  [bold]gitstow status[/bold] — {len(statuses)} repos\n")
+
+    table = Table(show_header=True, header_style="bold", box=None, padding=(0, 2))
+    if multi_ws:
+        table.add_column("Workspace", style="cyan")
+    table.add_column("Repo", style="white", min_width=20)
+    table.add_column("Branch")
+    table.add_column("Status")
+    table.add_column("Ahead/Behind")
+    table.add_column("Last Commit", style="dim")
+
+    for s in sorted(statuses, key=lambda x: x.get("workspace", "") + ":" + x["repo"]):
+        if "error" in s:
+            row = []
+            if multi_ws:
+                row.append(s.get("workspace", ""))
+            row.extend([s["repo"], "", f"[red]✗ {s['error']}[/red]", "", ""])
+            table.add_row(*row)
+            continue
+
+        # Status styling
+        if s.get("frozen"):
+            status_str = "[cyan]❄ frozen[/cyan]"
+        elif s.get("clean"):
+            status_str = "[green]✓ clean[/green]"
+        else:
+            symbol = s.get("status_symbol", "?")
+            dirty_count = s.get("dirty", 0) + s.get("staged", 0) + s.get("untracked", 0)
+            status_str = f"[yellow]{symbol} dirty({dirty_count})[/yellow]"
+
+        # Ahead/behind styling
+        ab = s.get("ahead_behind", "—")
+        if "↑" in ab and "↓" in ab:
+            ab_styled = f"[red]{ab}[/red]"
+        elif "↑" in ab:
+            ab_styled = f"[blue]{ab}[/blue]"
+        elif "↓" in ab:
+            ab_styled = f"[magenta]{ab}[/magenta]"
+        else:
+            ab_styled = f"[dim]{ab}[/dim]"
+
+        # Last commit
+        commit_str = s.get("last_commit", "")
+        if len(commit_str) > 40:
+            commit_str = commit_str[:37] + "..."
+        commit_date = s.get("last_commit_date", "")
+        if commit_date:
+            commit_str = f"{commit_str} ({commit_date})"
+
+        row = []
+        if multi_ws:
+            row.append(s.get("workspace", ""))
+        row.extend([s["repo"], s.get("branch", ""), status_str, ab_styled, commit_str])
+        table.add_row(*row)
+
+    console.print(table)
+
+    # Summary counts
+    clean = sum(1 for s in statuses if s.get("clean") and not s.get("frozen"))
+    dirty = sum(1 for s in statuses if not s.get("clean") and "error" not in s and not s.get("frozen"))
+    frozen = sum(1 for s in statuses if s.get("frozen"))
+    errors = sum(1 for s in statuses if "error" in s)
+
+    summary_parts = []
+    if clean:
+        summary_parts.append(f"[green]{clean} clean[/green]")
+    if dirty:
+        summary_parts.append(f"[yellow]{dirty} dirty[/yellow]")
+    if frozen:
+        summary_parts.append(f"[cyan]{frozen} frozen[/cyan]")
+    if errors:
+        summary_parts.append(f"[red]{errors} errors[/red]")
+
+    console.print(f"\n  {len(statuses)} repos: {', '.join(summary_parts)}\n")

gitstow/cli/tui.py

@@ -0,0 +1,27 @@
+"""gitstow tui — interactive terminal dashboard."""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+console = Console()
+
+
+def tui_cmd() -> None:
+    """[bold cyan]TUI[/bold cyan] — interactive terminal dashboard.
+
+    Browse, filter, and manage repos with keyboard navigation.
+    Requires textual: pip install gitstow[tui]
+    """
+    try:
+        from gitstow.tui.app import GitstowApp
+    except ImportError:
+        console.print(
+            "[red]Error:[/red] Textual is not installed. "
+            "Install it with: [bold]pip install gitstow[tui][/bold]"
+        )
+        raise typer.Exit(code=1)
+
+    app = GitstowApp()
+    app.run()

gitstow/cli/workspace_cmd.py

@@ -0,0 +1,202 @@
+"""gitstow workspace — manage workspaces (add, remove, list, scan)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from gitstow.core.config import Workspace, load_config, save_config
+from gitstow.core.discovery import discover_repos
+from gitstow.core.repo import Repo, RepoStore
+
+workspace_app = typer.Typer(
+    help="Manage workspaces — add, remove, list, scan.",
+    no_args_is_help=True,
+)
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+@workspace_app.command("list")
+def workspace_list(
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="One label per line."),
+) -> None:
+    """[bold]List[/bold] all configured workspaces."""
+    settings = load_config()
+    workspaces = settings.get_workspaces()
+    store = RepoStore()
+
+    if not workspaces:
+        if not quiet:
+            console.print("[dim]No workspaces configured. Run [bold]gitstow onboard[/bold].[/dim]")
+        return
+
+    if quiet:
+        for ws in workspaces:
+            print(ws.label)
+        return
+
+    table = Table(show_header=True, header_style="bold", box=None, padding=(0, 2))
+    table.add_column("Label", style="cyan")
+    table.add_column("Path")
+    table.add_column("Layout")
+    table.add_column("Auto-tags", style="dim")
+    table.add_column("Repos", justify="right")
+
+    ws_counts = store.all_workspaces()
+    for ws in workspaces:
+        count = ws_counts.get(ws.label, 0)
+        table.add_row(
+            ws.label,
+            ws.path,
+            ws.layout,
+            ", ".join(ws.auto_tags) if ws.auto_tags else "—",
+            str(count),
+        )
+
+    console.print()
+    console.print(table)
+    console.print()
+
+
+@workspace_app.command("add")
+def workspace_add(
+    path: str = typer.Argument(help="Path to the workspace directory."),
+    label: str = typer.Option(..., "--label", "-l", help="Unique label for this workspace."),
+    layout: str = typer.Option(
+        "structured",
+        "--layout",
+        help="Directory layout: 'structured' (owner/repo) or 'flat'.",
+    ),
+    auto_tags: Optional[list[str]] = typer.Option(
+        None, "--auto-tag", "-t", help="Tags to auto-apply to repos discovered in this workspace.",
+    ),
+    scan: bool = typer.Option(
+        True, "--scan/--no-scan", help="Scan for existing repos after adding.",
+    ),
+) -> None:
+    """[bold green]Add[/bold green] a new workspace."""
+    settings = load_config()
+
+    # Validate label uniqueness
+    if settings.get_workspace(label):
+        err_console.print(f"[red]Error:[/red] Workspace [bold]{label}[/bold] already exists.")
+        raise typer.Exit(code=1)
+
+    # Validate layout
+    if layout not in ("structured", "flat"):
+        err_console.print(f"[red]Error:[/red] Layout must be 'structured' or 'flat', got '{layout}'.")
+        raise typer.Exit(code=1)
+
+    resolved = Path(path).expanduser().resolve()
+    ws = Workspace(
+        path=str(resolved),
+        label=label,
+        layout=layout,
+        auto_tags=auto_tags or [],
+    )
+
+    settings.workspaces.append(ws)
+    save_config(settings)
+
+    # Create directory if needed
+    if not resolved.exists():
+        resolved.mkdir(parents=True, exist_ok=True)
+        console.print(f"  [green]✓[/green] Created {resolved}")
+
+    console.print(f"  [green]✓[/green] Workspace [bold]{label}[/bold] added ({layout} layout)")
+
+    if scan and resolved.exists():
+        _scan_workspace(ws)
+
+
+@workspace_app.command("remove")
+def workspace_remove(
+    label: str = typer.Argument(help="Label of the workspace to remove."),
+    keep_repos: bool = typer.Option(
+        True, "--keep-repos/--untrack-repos",
+        help="Keep tracked repos in the store (default) or untrack them.",
+    ),
+) -> None:
+    """[bold red]Remove[/bold red] a workspace from the configuration.
+
+    Does not delete files on disk. By default, repos remain tracked in the store.
+    """
+    settings = load_config()
+    ws = settings.get_workspace(label)
+    if ws is None:
+        err_console.print(f"[red]Error:[/red] Workspace [bold]{label}[/bold] not found.")
+        raise typer.Exit(code=1)
+
+    if len(settings.get_workspaces()) == 1:
+        err_console.print("[red]Error:[/red] Cannot remove the only workspace.")
+        raise typer.Exit(code=1)
+
+    settings.workspaces = [w for w in settings.workspaces if w.label != label]
+    save_config(settings)
+
+    if not keep_repos:
+        store = RepoStore()
+        repos = store.list_by_workspace(label)
+        for repo in repos:
+            store.remove(repo.key, workspace=label)
+        console.print(f"  [yellow]○[/yellow] Untracked {len(repos)} repos from [bold]{label}[/bold]")
+
+    console.print(f"  [green]✓[/green] Workspace [bold]{label}[/bold] removed")
+
+
+@workspace_app.command("scan")
+def workspace_scan(
+    label: str = typer.Argument(help="Label of the workspace to scan."),
+) -> None:
+    """[bold]Scan[/bold] a workspace to discover and register repos on disk."""
+    settings = load_config()
+    ws = settings.get_workspace(label)
+    if ws is None:
+        err_console.print(f"[red]Error:[/red] Workspace [bold]{label}[/bold] not found.")
+        raise typer.Exit(code=1)
+
+    _scan_workspace(ws)
+
+
+def _scan_workspace(ws: Workspace) -> None:
+    """Discover repos in a workspace and register any untracked ones."""
+    store = RepoStore()
+    resolved = ws.get_path()
+
+    if not resolved.is_dir():
+        console.print(f"  [dim]Workspace directory does not exist: {resolved}[/dim]")
+        return
+
+    found = discover_repos(resolved, layout=ws.layout)
+    existing = {r.key for r in store.list_by_workspace(ws.label)}
+
+    new_repos = [r for r in found if r.key not in existing]
+
+    if not new_repos:
+        console.print(f"  [dim]No new repos found in [bold]{ws.label}[/bold].[/dim]")
+        return
+
+    console.print(f"  Found {len(new_repos)} new repo{'s' if len(new_repos) != 1 else ''}:")
+    for dr in new_repos:
+        console.print(f"    {dr.key}")
+
+    # Register them
+    for dr in new_repos:
+        repo = Repo(
+            owner=dr.owner,
+            name=dr.name,
+            remote_url=dr.remote_url or "",
+            workspace=ws.label,
+            tags=list(ws.auto_tags),
+        )
+        store.add(repo)
+
+    console.print(
+        f"  [green]✓[/green] Registered {len(new_repos)} repos in [bold]{ws.label}[/bold]"
+    )

gitstow/core/__init__.py

@@ -0,0 +1 @@
+"""gitstow core — business logic, git operations, and state management."""

gitstow/core/config.py

@@ -0,0 +1,130 @@
+"""Settings management — load, save, and validate config.
+
+Supports multiple workspaces, each with its own path and layout mode.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import yaml
+
+from gitstow.core.paths import CONFIG_FILE, DEFAULT_ROOT, ensure_app_dirs
+
+
+@dataclass
+class Workspace:
+    """A configured workspace — a directory that gitstow manages repos in."""
+
+    path: str                              # e.g., "~/oss"
+    label: str                             # e.g., "oss" (unique identifier)
+    layout: str = "structured"             # "structured" (owner/repo) or "flat"
+    auto_tags: list[str] = field(default_factory=list)
+
+    def get_path(self) -> Path:
+        """Resolve the workspace path to an absolute Path."""
+        return Path(self.path).expanduser().resolve()
+
+    def to_dict(self) -> dict:
+        d: dict = {"path": self.path, "label": self.label, "layout": self.layout}
+        if self.auto_tags:
+            d["auto_tags"] = self.auto_tags
+        return d
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Workspace:
+        return cls(
+            path=data.get("path", ""),
+            label=data.get("label", ""),
+            layout=data.get("layout", "structured"),
+            auto_tags=data.get("auto_tags", []),
+        )
+
+
+@dataclass
+class Settings:
+    workspaces: list[Workspace] = field(default_factory=list)
+    default_host: str = "github.com"
+    prefer_ssh: bool = False
+    parallel_limit: int = 6
+
+    # Legacy field — only used for migration from pre-workspace configs
+    root_path: str = ""
+
+    def get_workspaces(self) -> list[Workspace]:
+        """Return all workspaces. If none configured, synthesize one from legacy root_path."""
+        if self.workspaces:
+            return self.workspaces
+        # Backward compat: synthesize a single workspace from legacy root_path
+        path = self.root_path or str(DEFAULT_ROOT)
+        return [Workspace(path=path, label="oss", layout="structured")]
+
+    def get_workspace(self, label: str) -> Workspace | None:
+        """Look up a workspace by label."""
+        for ws in self.get_workspaces():
+            if ws.label == label:
+                return ws
+        return None
+
+    def get_default_workspace(self) -> Workspace:
+        """Return the first workspace (used as default for add, etc.)."""
+        return self.get_workspaces()[0]
+
+    def get_root(self) -> Path:
+        """Deprecated — returns the default workspace path for backward compat."""
+        return self.get_default_workspace().get_path()
+
+    def to_dict(self) -> dict:
+        d: dict = {
+            "workspaces": [ws.to_dict() for ws in self.workspaces],
+            "default_host": self.default_host,
+            "prefer_ssh": self.prefer_ssh,
+            "parallel_limit": self.parallel_limit,
+        }
+        # Don't serialize root_path if workspaces are configured
+        if not self.workspaces and self.root_path:
+            d["root_path"] = self.root_path
+        return d
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Settings:
+        workspaces_data = data.get("workspaces", [])
+        workspaces = [Workspace.from_dict(ws) for ws in workspaces_data]
+        return cls(
+            workspaces=workspaces,
+            default_host=data.get("default_host", "github.com"),
+            prefer_ssh=data.get("prefer_ssh", False),
+            parallel_limit=data.get("parallel_limit", 6),
+            root_path=data.get("root_path", ""),
+        )
+
+
+def load_config() -> Settings:
+    """Load settings from config.yaml. Returns defaults if file doesn't exist."""
+    if not CONFIG_FILE.exists():
+        return Settings()
+    with open(CONFIG_FILE) as f:
+        data = yaml.safe_load(f) or {}
+    settings = Settings.from_dict(data)
+
+    # Auto-migrate: if legacy root_path is set but no workspaces, migrate
+    if not settings.workspaces and settings.root_path:
+        settings.workspaces = [
+            Workspace(
+                path=settings.root_path,
+                label="oss",
+                layout="structured",
+            )
+        ]
+        settings.root_path = ""
+        save_config(settings)
+
+    return settings
+
+
+def save_config(settings: Settings) -> None:
+    """Write settings to config.yaml."""
+    ensure_app_dirs()
+    with open(CONFIG_FILE, "w") as f:
+        yaml.dump(settings.to_dict(), f, default_flow_style=False, sort_keys=False)