gitstow 0.1.0__py3-none-any.whl

gitstow/cli/list_cmd.py

@@ -0,0 +1,213 @@
+"""gitstow list — show all repos grouped by owner or workspace."""
+
+from __future__ import annotations
+
+import json
+import sys
+from collections import defaultdict
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from gitstow.core.config import load_config
+from gitstow.core.repo import RepoStore
+from gitstow.cli.helpers import iter_repos_with_workspace
+
+console = Console()
+
+
+def list_repos(
+    ctx: typer.Context,
+    query: Optional[str] = typer.Argument(
+        default=None,
+        help="Filter repos by substring match.",
+    ),
+    tag: Optional[list[str]] = typer.Option(
+        None, "--tag", "-t", help="Filter by tag.",
+    ),
+    owner: Optional[str] = typer.Option(
+        None, "--owner", help="Filter by owner.",
+    ),
+    frozen_only: bool = typer.Option(
+        False, "--frozen", help="Show only frozen repos.",
+    ),
+    show_paths: bool = typer.Option(
+        False, "--paths", "-p", help="Show full paths.",
+    ),
+    output_json: bool = typer.Option(
+        False, "--json", "-j", help="JSON output.",
+    ),
+    quiet: bool = typer.Option(
+        False, "--quiet", "-q", help="Minimal output.",
+    ),
+) -> None:
+    """[bold]List[/bold] all tracked repos, grouped by owner.
+
+    \b
+    Examples:
+      gitstow list                    # All repos
+      gitstow list react              # Substring search
+      gitstow list --tag ai           # Filter by tag
+      gitstow list --owner anthropic  # Filter by owner
+      gitstow list --frozen           # Only frozen repos
+      gitstow list -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 frozen_only:
+        repo_ws_pairs = [(r, ws) for r, ws in repo_ws_pairs if r.frozen]
+
+    if query:
+        q = query.lower()
+        repo_ws_pairs = [(r, ws) for r, ws in repo_ws_pairs if q in r.key.lower()]
+
+    if not repo_ws_pairs:
+        if not quiet:
+            console.print("[dim]No repos found.[/dim]")
+        if output_json:
+            json.dump([], sys.stdout, indent=2)
+            print()
+        return
+
+    # Quiet mode: one key per line (for shell completions and scripting)
+    if quiet:
+        for r, _ in repo_ws_pairs:
+            print(r.key)
+        return
+
+    if output_json:
+        json.dump(
+            [
+                {
+                    "owner": r.owner,
+                    "name": r.name,
+                    "key": r.key,
+                    "workspace": r.workspace,
+                    "remote_url": r.remote_url,
+                    "path": str(r.get_path(ws.get_path())),
+                    "frozen": r.frozen,
+                    "tags": r.tags,
+                    "added": r.added,
+                    "last_pulled": r.last_pulled,
+                }
+                for r, ws in repo_ws_pairs
+            ],
+            sys.stdout,
+            indent=2,
+        )
+        print()
+        return
+
+    repos = [r for r, _ in repo_ws_pairs]
+    ws_map = {r.global_key: ws for r, ws in repo_ws_pairs}
+
+    # Check if multiple workspaces
+    ws_labels = {r.workspace for r in repos}
+    multi_ws = len(ws_labels) > 1
+
+    # Group by workspace then owner
+    if multi_ws:
+        by_ws: dict[str, list] = defaultdict(list)
+        for r in repos:
+            by_ws[r.workspace].append(r)
+
+        total = len(repos)
+        console.print(
+            f"\n  [bold]gitstow[/bold] — {total} repo{'s' if total != 1 else ''} "
+            f"across {len(by_ws)} workspace{'s' if len(by_ws) != 1 else ''}\n"
+        )
+
+        max_name_len = max(len(r.name) for r in repos) if repos else 0
+
+        for ws_name in sorted(by_ws.keys()):
+            ws_repos = by_ws[ws_name]
+            console.print(f"  [bold cyan]{ws_name}[/bold cyan] ({len(ws_repos)} repos)")
+            _print_repos_grouped(ws_repos, ws_map, max_name_len, show_paths)
+            console.print()
+    else:
+        # Single workspace — group by owner (original behavior)
+        by_owner: dict[str, list] = defaultdict(list)
+        for r in repos:
+            by_owner[r.owner or r.workspace].append(r)
+
+        total = len(repos)
+        group_count = len(by_owner)
+        console.print(
+            f"\n  [bold]gitstow[/bold] — {total} repo{'s' if total != 1 else ''} "
+            f"across {group_count} owner{'s' if group_count != 1 else ''}\n"
+        )
+
+        max_name_len = max(len(r.name) for r in repos) if repos else 0
+        _print_repos_grouped(repos, ws_map, max_name_len, show_paths)
+
+
+def _print_repos_grouped(repos, ws_map, max_name_len, show_paths):
+    """Print repos grouped by owner."""
+    by_owner: dict[str, list] = defaultdict(list)
+    for r in repos:
+        by_owner[r.owner or "(flat)"].append(r)
+
+    for owner_name in sorted(by_owner.keys()):
+        owner_repos = by_owner[owner_name]
+        if owner_name != "(flat)":
+            console.print(f"    [bold]{owner_name}/[/bold] ({len(owner_repos)} repo{'s' if len(owner_repos) != 1 else ''})")
+        indent = "      " if owner_name != "(flat)" else "    "
+
+        for r in sorted(owner_repos, key=lambda x: x.name):
+            name_padded = r.name.ljust(max_name_len)
+            frozen_str = " [cyan]❄ frozen[/cyan]" if r.frozen else ""
+            tags_str = f"  [dim][{', '.join(r.tags)}][/dim]" if r.tags else ""
+            pulled_str = ""
+            if r.last_pulled:
+                pulled_str = f"  [dim]{_format_relative_time(r.last_pulled)}[/dim]"
+
+            if show_paths:
+                ws = ws_map.get(r.global_key)
+                path = r.get_path(ws.get_path()) if ws else ""
+                path_str = f"  [dim]{path}[/dim]"
+                console.print(f"{indent}{name_padded}{frozen_str}{tags_str}{path_str}")
+            else:
+                console.print(f"{indent}{name_padded}{frozen_str}{tags_str}{pulled_str}")
+
+
+def _format_relative_time(iso_str: str) -> str:
+    """Format an ISO datetime as a relative time string."""
+    from datetime import datetime
+
+    try:
+        dt = datetime.fromisoformat(iso_str)
+        now = datetime.now()
+        diff = now - dt
+
+        seconds = diff.total_seconds()
+        if seconds < 60:
+            return "just now"
+        elif seconds < 3600:
+            mins = int(seconds / 60)
+            return f"{mins}m ago"
+        elif seconds < 86400:
+            hours = int(seconds / 3600)
+            return f"{hours}h ago"
+        elif seconds < 604800:
+            days = int(seconds / 86400)
+            return f"{days}d ago"
+        elif seconds < 2592000:
+            weeks = int(seconds / 604800)
+            return f"{weeks}w ago"
+        else:
+            months = int(seconds / 2592000)
+            return f"{months}mo ago"
+    except (ValueError, TypeError):
+        return ""

gitstow/cli/main.py

@@ -0,0 +1,129 @@
+"""gitstow — main CLI entry point."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from gitstow import __version__
+from gitstow.core.paths import CLAUDE_SKILLS_DIR
+
+app = typer.Typer(
+    name="gitstow",
+    help="A git repository library manager — clone, organize, and maintain collections of repos.",
+    rich_markup_mode="rich",
+    no_args_is_help=True,
+)
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        console.print(f"gitstow v{__version__}")
+        raise typer.Exit()
+
+
+def _auto_update_skill() -> None:
+    """Silently update the Claude Code skill if the version has changed.
+
+    Checks a .version marker file in the installed skill directory.
+    If it doesn't match the current package version, re-copies SKILL.md.
+    This runs on every invocation but is fast (one file read + compare).
+    """
+    skill_dir = CLAUDE_SKILLS_DIR / "gitstow"
+    version_marker = skill_dir / ".version"
+
+    if not skill_dir.exists():
+        # Skill not installed — don't auto-install (user hasn't opted in)
+        return
+
+    # Check version marker
+    try:
+        installed_version = version_marker.read_text().strip()
+    except (FileNotFoundError, OSError):
+        installed_version = ""
+
+    if installed_version == __version__:
+        return  # Already up to date
+
+    # Version mismatch — silently update
+    try:
+        from gitstow.cli.skill_cmd import _do_install_skill
+        _do_install_skill(quiet=True)
+        version_marker.write_text(__version__)
+    except Exception:
+        pass  # Never block CLI on skill update failure
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    version: Optional[bool] = typer.Option(
+        None,
+        "--version",
+        "-v",
+        help="Show version and exit.",
+        callback=version_callback,
+        is_eager=True,
+    ),
+    workspace: Optional[str] = typer.Option(
+        None,
+        "--workspace",
+        "-w",
+        help="Filter to a specific workspace.",
+    ),
+) -> None:
+    """[bold]gitstow[/bold] — clone, organize, and maintain collections of git repos."""
+    ctx.ensure_object(dict)
+    ctx.obj["workspace"] = workspace
+    _auto_update_skill()
+
+
+# --- Register Stage 1 commands ---
+from gitstow.cli.add import add  # noqa: E402
+from gitstow.cli.pull import pull  # noqa: E402
+from gitstow.cli.list_cmd import list_repos  # noqa: E402
+from gitstow.cli.status import status  # noqa: E402
+from gitstow.cli.remove import remove  # noqa: E402
+from gitstow.cli.manage import manage_app  # noqa: E402
+from gitstow.cli.migrate import migrate  # noqa: E402
+from gitstow.cli.config_cmd import config_app  # noqa: E402
+from gitstow.cli.onboard import onboard  # noqa: E402
+from gitstow.cli.skill_cmd import install_skill  # noqa: E402
+from gitstow.cli.doctor import doctor  # noqa: E402
+
+# --- Register Stage 2 commands ---
+from gitstow.cli.exec_cmd import exec_cmd  # noqa: E402
+from gitstow.cli.search import search  # noqa: E402
+from gitstow.cli.open_cmd import open_repo  # noqa: E402
+from gitstow.cli.stats import stats  # noqa: E402
+from gitstow.cli.export_cmd import export_app  # noqa: E402
+from gitstow.cli.shell import shell_app  # noqa: E402
+from gitstow.cli.tui import tui_cmd  # noqa: E402
+from gitstow.cli.setup_ai import setup_ai  # noqa: E402
+from gitstow.cli.workspace_cmd import workspace_app  # noqa: E402
+
+app.command()(add)
+app.command()(pull)
+app.command("list")(list_repos)
+app.command()(status)
+app.command()(remove)
+app.command()(migrate)
+app.command()(onboard)
+app.command("install-skill")(install_skill)
+app.command()(doctor)
+app.command("exec")(exec_cmd)
+app.command()(search)
+app.command("open")(open_repo)
+app.command()(stats)
+app.add_typer(config_app, name="config")
+app.add_typer(manage_app, name="repo", help="Manage individual repos — freeze, tag, info.")
+app.add_typer(export_app, name="collection", help="Export and import repo collections.")
+app.command("tui")(tui_cmd)
+app.command("setup-ai")(setup_ai)
+app.add_typer(shell_app, name="shell", help="Shell integration — fzf picker, cd helper, setup.")
+app.add_typer(workspace_app, name="workspace", help="Manage workspaces — add, remove, list, scan.")

gitstow/cli/manage.py

@@ -0,0 +1,283 @@
+"""gitstow repo — manage individual repos (freeze, tag, info)."""
+
+from __future__ import annotations
+
+import json
+import sys
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from gitstow.core.config import load_config
+from gitstow.core.git import (
+    get_status,
+    get_last_commit,
+    get_disk_size,
+    format_size,
+    is_git_repo,
+)
+from gitstow.core.repo import RepoStore
+from gitstow.cli.helpers import resolve_repo
+
+manage_app = typer.Typer(
+    help="Manage individual repos — freeze, tag, info.",
+    no_args_is_help=True,
+)
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+@manage_app.command()
+def freeze(
+    repo_key: Optional[str] = typer.Argument(default=None, help="Repo to freeze (owner/repo). Optional if --tag is used."),
+    tag_filter: Optional[str] = typer.Option(
+        None, "--tag", "-t", help="Freeze all repos with this tag instead.",
+    ),
+) -> None:
+    """[bold cyan]Freeze[/bold cyan] a repo — skip it during pull.
+
+    \b
+    Examples:
+      gitstow repo freeze facebook/react
+      gitstow repo freeze --tag archived
+    """
+    store = RepoStore()
+
+    if tag_filter:
+        repos = store.list_by_tag(tag_filter)
+        if not repos:
+            err_console.print(f"[yellow]No repos with tag '{tag_filter}'.[/yellow]")
+            return
+        for repo in repos:
+            store.update(repo.key, frozen=True)
+        console.print(f"  [cyan]❄[/cyan] Froze {len(repos)} repos with tag '{tag_filter}'.")
+        return
+
+    if not repo_key:
+        err_console.print("[red]Error:[/red] Provide a repo key or use --tag.")
+        raise typer.Exit(code=1)
+
+    repo = store.get(repo_key)
+    if not repo:
+        err_console.print(f"[red]Error:[/red] '{repo_key}' not tracked.")
+        raise typer.Exit(code=1)
+
+    if repo.frozen:
+        console.print(f"  [dim]{repo_key} is already frozen.[/dim]")
+        return
+
+    store.update(repo_key, frozen=True)
+    console.print(f"  [cyan]❄[/cyan] {repo_key} frozen. It will be skipped during pull.")
+
+
+@manage_app.command()
+def unfreeze(
+    repo_key: Optional[str] = typer.Argument(default=None, help="Repo to unfreeze (owner/repo). Optional if --tag is used."),
+    tag_filter: Optional[str] = typer.Option(
+        None, "--tag", "-t", help="Unfreeze all repos with this tag.",
+    ),
+) -> None:
+    """[bold green]Unfreeze[/bold green] a repo — re-enable pulling.
+
+    \b
+    Examples:
+      gitstow repo unfreeze facebook/react
+      gitstow repo unfreeze --tag archived
+    """
+    store = RepoStore()
+
+    if tag_filter:
+        repos = store.list_by_tag(tag_filter)
+        frozen = [r for r in repos if r.frozen]
+        if not frozen:
+            console.print(f"  [dim]No frozen repos with tag '{tag_filter}'.[/dim]")
+            return
+        for repo in frozen:
+            store.update(repo.key, frozen=False)
+        console.print(f"  [green]✓[/green] Unfroze {len(frozen)} repos with tag '{tag_filter}'.")
+        return
+
+    if not repo_key:
+        err_console.print("[red]Error:[/red] Provide a repo key or use --tag.")
+        raise typer.Exit(code=1)
+
+    repo = store.get(repo_key)
+    if not repo:
+        err_console.print(f"[red]Error:[/red] '{repo_key}' not tracked.")
+        raise typer.Exit(code=1)
+
+    if not repo.frozen:
+        console.print(f"  [dim]{repo_key} is not frozen.[/dim]")
+        return
+
+    store.update(repo_key, frozen=False)
+    console.print(f"  [green]✓[/green] {repo_key} unfrozen.")
+
+
+@manage_app.command("tag")
+def add_tags(
+    repo_key: str = typer.Argument(help="Repo to tag (owner/repo)."),
+    tags: list[str] = typer.Argument(help="Tag(s) to add."),
+) -> None:
+    """[bold]Tag[/bold] a repo with one or more labels.
+
+    \b
+    Examples:
+      gitstow repo tag anthropic/claude-code ai tools
+    """
+    store = RepoStore()
+    repo = store.get(repo_key)
+    if not repo:
+        err_console.print(f"[red]Error:[/red] '{repo_key}' not tracked.")
+        raise typer.Exit(code=1)
+
+    new_tags = list(set(repo.tags + [t.lower() for t in tags]))
+    added = [t for t in new_tags if t not in repo.tags]
+    store.update(repo_key, tags=new_tags)
+
+    if added:
+        console.print(f"  [green]✓[/green] {repo_key} tagged: {', '.join(added)}")
+    else:
+        console.print("  [dim]No new tags added (already tagged).[/dim]")
+
+
+@manage_app.command("untag")
+def remove_tags(
+    repo_key: str = typer.Argument(help="Repo to untag (owner/repo)."),
+    tags: list[str] = typer.Argument(help="Tag(s) to remove."),
+) -> None:
+    """Remove tag(s) from a repo.
+
+    \b
+    Examples:
+      gitstow repo untag anthropic/claude-code tools
+    """
+    store = RepoStore()
+    repo = store.get(repo_key)
+    if not repo:
+        err_console.print(f"[red]Error:[/red] '{repo_key}' not tracked.")
+        raise typer.Exit(code=1)
+
+    removed = [t for t in tags if t in repo.tags]
+    new_tags = [t for t in repo.tags if t not in tags]
+    store.update(repo_key, tags=new_tags)
+
+    if removed:
+        console.print(f"  [green]✓[/green] Removed tags from {repo_key}: {', '.join(removed)}")
+    else:
+        console.print(f"  [dim]None of those tags were on {repo_key}.[/dim]")
+
+
+@manage_app.command("tags")
+def list_tags(
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="One tag per line."),
+) -> None:
+    """List all tags with repo counts."""
+    store = RepoStore()
+    tags = store.all_tags()
+
+    if not tags:
+        if not quiet:
+            console.print("[dim]No tags defined.[/dim]")
+        return
+
+    if quiet:
+        for tag in sorted(tags):
+            print(tag)
+        return
+
+    console.print("\n  [bold]Tags[/bold]\n")
+    for tag, count in tags.items():
+        console.print(f"    {tag}  [dim]({count} repo{'s' if count != 1 else ''})[/dim]")
+    console.print()
+
+
+@manage_app.command()
+def info(
+    ctx: typer.Context,
+    repo_key: str = typer.Argument(help="Repo to inspect (owner/repo or name)."),
+    output_json: bool = typer.Option(
+        False, "--json", "-j", help="JSON output.",
+    ),
+) -> None:
+    """[bold]Info[/bold] — detailed view of a single repo.
+
+    \b
+    Examples:
+      gitstow repo info anthropic/claude-code
+    """
+    settings = load_config()
+    store = RepoStore()
+    ws_label = (ctx.obj or {}).get("workspace")
+
+    repo, ws = resolve_repo(store, settings, repo_key, ws_label)
+    path = repo.get_path(ws.get_path())
+    info_data = {
+        "repo": repo.key,
+        "workspace": repo.workspace,
+        "remote_url": repo.remote_url,
+        "path": str(path),
+        "frozen": repo.frozen,
+        "tags": repo.tags,
+        "added": repo.added,
+        "last_pulled": repo.last_pulled,
+        "exists_on_disk": path.exists(),
+    }
+
+    # Git info (if repo exists on disk)
+    if path.exists() and is_git_repo(path):
+        status = get_status(path)
+        commit = get_last_commit(path)
+        size = get_disk_size(path)
+
+        info_data.update({
+            "branch": status.branch,
+            "status": "clean" if status.clean else status.status_symbol,
+            "ahead": status.ahead,
+            "behind": status.behind,
+            "last_commit_hash": commit.hash,
+            "last_commit_message": commit.message,
+            "last_commit_date": commit.date,
+            "last_commit_author": commit.author,
+            "disk_size": size,
+            "disk_size_human": format_size(size),
+        })
+
+    if output_json:
+        json.dump(info_data, sys.stdout, indent=2)
+        print()
+        return
+
+    # Human-readable display
+    console.print(f"\n  [bold]{repo.key}[/bold]\n")
+
+    rows = [
+        ("Remote", repo.remote_url),
+        ("Path", str(path)),
+    ]
+
+    if path.exists() and is_git_repo(path):
+        rows.extend([
+            ("Branch", info_data.get("branch", "unknown")),
+            ("Status", info_data.get("status", "unknown")),
+            ("Frozen", "[cyan]yes[/cyan]" if repo.frozen else "no"),
+            ("Tags", ", ".join(repo.tags) if repo.tags else "[dim]none[/dim]"),
+            ("Added", repo.added or "[dim]unknown[/dim]"),
+            ("Last pulled", repo.last_pulled or "[dim]never[/dim]"),
+            ("Disk size", info_data.get("disk_size_human", "unknown")),
+            ("Last commit", f"{info_data.get('last_commit_message', '')} ({info_data.get('last_commit_date', '')})"),
+        ])
+    else:
+        rows.extend([
+            ("Frozen", "[cyan]yes[/cyan]" if repo.frozen else "no"),
+            ("Tags", ", ".join(repo.tags) if repo.tags else "[dim]none[/dim]"),
+            ("On disk", "[red]not found[/red]" if not path.exists() else "[yellow]not a git repo[/yellow]"),
+        ])
+
+    max_label = max(len(r[0]) for r in rows)
+    for label, value in rows:
+        console.print(f"    {label.ljust(max_label + 2)}{value}")
+
+    console.print()