gitstow 0.1.0__py3-none-any.whl

gitstow/cli/pull.py

@@ -0,0 +1,265 @@
+"""gitstow pull — bulk update repos."""
+
+from __future__ import annotations
+
+import json
+import sys
+from datetime import datetime
+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 pull as git_pull, get_status, is_git_repo
+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 _pull_one_repo(repo: Repo, ws: Workspace) -> dict:
+    """Pull a single repo. Returns a result dict."""
+    path = repo.get_path(ws.get_path())
+
+    if not path.exists():
+        return {"repo": repo.key, "status": "missing", "detail": "Directory not found on disk"}
+
+    if not is_git_repo(path):
+        return {"repo": repo.key, "status": "error", "detail": "Not a git repo"}
+
+    status = get_status(path)
+    if not status.clean:
+        return {
+            "repo": repo.key,
+            "status": "skipped",
+            "detail": f"Dirty working tree ({status.status_symbol})",
+        }
+
+    result = git_pull(path)
+    if result.success:
+        if result.already_up_to_date:
+            return {"repo": repo.key, "status": "up_to_date", "detail": "Already up to date"}
+        else:
+            return {"repo": repo.key, "status": "pulled", "detail": result.output.split("\n")[0]}
+    else:
+        return {"repo": repo.key, "status": "error", "detail": result.error}
+
+
+def pull(
+    ctx: typer.Context,
+    repos: Optional[list[str]] = typer.Argument(
+        default=None,
+        help="Specific repos to pull (owner/repo). Omit for all.",
+    ),
+    tag: Optional[list[str]] = typer.Option(
+        None, "--tag", "-t", help="Only pull repos with this tag.",
+    ),
+    exclude_tag: Optional[list[str]] = typer.Option(
+        None, "--exclude-tag", help="Skip repos with this tag.",
+    ),
+    owner: Optional[str] = typer.Option(
+        None, "--owner", help="Only pull repos from this owner.",
+    ),
+    include_frozen: bool = typer.Option(
+        False, "--include-frozen", help="Include frozen repos.",
+    ),
+    output_json: bool = typer.Option(
+        False, "--json", "-j", help="JSON output.",
+    ),
+    retry: int = typer.Option(
+        0, "--retry", help="Retry failed repos N times.",
+    ),
+    quiet: bool = typer.Option(
+        False, "--quiet", "-q", help="Suppress per-repo progress.",
+    ),
+) -> None:
+    """[bold blue]Pull[/bold blue] latest changes for all (or filtered) repos.
+
+    Frozen repos are skipped unless --include-frozen is set.
+    Dirty repos are always skipped (never risk losing local changes).
+
+    \b
+    Examples:
+      gitstow pull                    # All unfrozen repos
+      gitstow pull --tag ai           # Only repos tagged 'ai'
+      gitstow pull --exclude-tag stale
+      gitstow pull -w oss             # Only repos in oss workspace
+    """
+    settings = load_config()
+    store = RepoStore()
+    ws_label = ctx.obj.get("workspace") if ctx.obj else None
+
+    # Resolve target repos
+    if repos:
+        targets = []
+        for key in repos:
+            repo = store.get(key)
+            if repo:
+                ws = settings.get_workspace(repo.workspace)
+                if ws:
+                    targets.append((repo, ws))
+            else:
+                err_console.print(f"[yellow]Warning:[/yellow] '{key}' not tracked. Skipping.")
+    else:
+        targets = iter_repos_with_workspace(store, settings, ws_label)
+
+    # Apply filters
+    if not include_frozen:
+        frozen_keys = {r.key for r, _ in targets if r.frozen}
+        targets = [(r, ws) for r, ws in targets if not r.frozen]
+    else:
+        frozen_keys = set()
+
+    if tag:
+        tag_set = set(tag)
+        targets = [(r, ws) for r, ws in targets if tag_set.intersection(r.tags)]
+
+    if exclude_tag:
+        exclude_set = set(exclude_tag)
+        targets = [(r, ws) for r, ws in targets if not exclude_set.intersection(r.tags)]
+
+    if owner:
+        targets = [(r, ws) for r, ws in targets if r.owner == owner]
+
+    if not targets:
+        if not quiet:
+            console.print("[yellow]No repos to pull.[/yellow]")
+        if output_json:
+            json.dump({"total": 0, "results": []}, sys.stdout, indent=2)
+            print()
+        return
+
+    total_count = len(targets)
+    if not quiet:
+        console.print(f"\n  Pulling {total_count} repo{'s' if total_count != 1 else ''}...\n")
+
+    # Run pulls in parallel (with retry)
+    remaining_targets = list(targets)
+    result_dicts: list[dict] = []
+
+    for attempt in range(1 + retry):
+        if attempt > 0 and not quiet:
+            console.print(f"\n  [dim]Retry {attempt}/{retry} — {len(remaining_targets)} failed repos...[/dim]\n")
+
+        tasks = [
+            (repo.global_key, lambda r=repo, w=ws: _pull_one_repo(r, w))
+            for repo, ws in remaining_targets
+        ]
+
+        progress_count = [0]
+
+        def _on_progress(key: str, success: bool, message: str) -> None:
+            progress_count[0] += 1
+            if not quiet:
+                console.print(
+                    f"  [{progress_count[0]}/{len(tasks)}] {key.split(':', 1)[-1]}",
+                    end="\r",
+                    highlight=False,
+                )
+
+        results = run_parallel_sync(
+            tasks,
+            max_concurrent=settings.parallel_limit,
+            on_progress=None if quiet else _on_progress,
+        )
+
+        # Process results and update timestamps
+        failed_keys: set[str] = set()
+        for task_result in results:
+            if task_result.success and task_result.data:
+                data = task_result.data
+                if data["status"] in ("pulled", "up_to_date", "skipped"):
+                    result_dicts.append(data)
+                    if data["status"] in ("pulled", "up_to_date"):
+                        parts = task_result.key.split(":", 1)
+                        if len(parts) == 2:
+                            store.update(parts[1], workspace=parts[0], last_pulled=datetime.now().isoformat())
+                else:
+                    # error or missing — candidate for retry
+                    if attempt < retry:
+                        failed_keys.add(task_result.key)
+                    else:
+                        result_dicts.append(data)
+            else:
+                if attempt < retry:
+                    failed_keys.add(task_result.key)
+                else:
+                    result_dicts.append({
+                        "repo": task_result.key,
+                        "status": "error",
+                        "detail": task_result.error,
+                    })
+
+        if not failed_keys:
+            break
+        remaining_targets = [(r, ws) for r, ws in remaining_targets if r.global_key in failed_keys]
+
+    # Add frozen repos to results for completeness
+    if not include_frozen and frozen_keys:
+        for key in sorted(frozen_keys):
+            result_dicts.append({"repo": key, "status": "frozen", "detail": "Skipped (frozen)"})
+
+    # Output
+    if output_json:
+        pulled = sum(1 for r in result_dicts if r["status"] == "pulled")
+        up_to_date = sum(1 for r in result_dicts if r["status"] == "up_to_date")
+        skipped = sum(1 for r in result_dicts if r["status"] in ("skipped", "frozen"))
+        errors = sum(1 for r in result_dicts if r["status"] == "error")
+        missing = sum(1 for r in result_dicts if r["status"] == "missing")
+
+        json.dump(
+            {
+                "total": len(result_dicts),
+                "pulled": pulled,
+                "up_to_date": up_to_date,
+                "skipped": skipped,
+                "errors": errors + missing,
+                "results": result_dicts,
+            },
+            sys.stdout,
+            indent=2,
+        )
+        print()
+    else:
+        table = Table(show_header=True, header_style="bold", box=None, padding=(0, 2))
+        table.add_column("Repo", style="white")
+        table.add_column("Status")
+        table.add_column("Details", style="dim")
+
+        status_styles = {
+            "pulled": "[green]✓ Pulled[/green]",
+            "up_to_date": "[dim]○ Up to date[/dim]",
+            "frozen": "[cyan]❄ Frozen[/cyan]",
+            "skipped": "[yellow]⚠ Skipped[/yellow]",
+            "error": "[red]✗ Error[/red]",
+            "missing": "[red]✗ Missing[/red]",
+        }
+
+        for r in sorted(result_dicts, key=lambda x: x["repo"]):
+            status_text = status_styles.get(r["status"], r["status"])
+            table.add_row(r["repo"], status_text, r.get("detail", ""))
+
+        console.print(table)
+
+        pulled = sum(1 for r in result_dicts if r["status"] == "pulled")
+        up_to_date = sum(1 for r in result_dicts if r["status"] == "up_to_date")
+        skipped = sum(1 for r in result_dicts if r["status"] in ("skipped", "frozen"))
+        errors = sum(1 for r in result_dicts if r["status"] in ("error", "missing"))
+
+        parts = []
+        if pulled:
+            parts.append(f"[green]{pulled} pulled[/green]")
+        if up_to_date:
+            parts.append(f"[dim]{up_to_date} up to date[/dim]")
+        if skipped:
+            parts.append(f"[cyan]{skipped} skipped[/cyan]")
+        if errors:
+            parts.append(f"[red]{errors} errors[/red]")
+        console.print(f"\n  {' | '.join(parts)}\n")
+
+    if any(r["status"] in ("error", "missing") for r in result_dicts):
+        raise typer.Exit(code=1)

gitstow/cli/remove.py

@@ -0,0 +1,88 @@
+"""gitstow remove — remove a repo from the collection."""
+
+from __future__ import annotations
+
+import json
+import shutil
+import sys
+
+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 resolve_repo
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+def remove(
+    ctx: typer.Context,
+    repo_key: str = typer.Argument(
+        help="Repo to remove (owner/repo or name).",
+    ),
+    yes: bool = typer.Option(
+        False, "--yes", "-y", help="Skip confirmation prompt.",
+    ),
+    delete_files: bool = typer.Option(
+        False, "--delete", help="Also delete the repo from disk.",
+    ),
+    output_json: bool = typer.Option(
+        False, "--json", "-j", help="JSON output.",
+    ),
+) -> None:
+    """[bold red]Remove[/bold red] a repo from tracking.
+
+    By default, only removes from gitstow's registry. The files stay on disk.
+    Use --delete to also remove the directory.
+
+    \b
+    Examples:
+      gitstow remove facebook/react
+      gitstow remove facebook/react --delete --yes
+      gitstow remove -w active gitstow
+    """
+    settings = load_config()
+    store = RepoStore()
+    ws_label = ctx.obj.get("workspace") if ctx.obj else None
+
+    repo, ws = resolve_repo(store, settings, repo_key, ws_label)
+    path = repo.get_path(ws.get_path())
+
+    # Confirmation
+    if not yes:
+        action = "remove from tracking and delete from disk" if delete_files else "remove from tracking"
+        if not typer.confirm(f"  {action}: {repo.key} ({ws.label})?"):
+            console.print("  [dim]Cancelled.[/dim]")
+            raise typer.Exit()
+
+    # Remove from store
+    store.remove(repo.key, workspace=ws.label)
+
+    # Optionally delete from disk
+    deleted = False
+    if delete_files and path.exists():
+        shutil.rmtree(path, ignore_errors=True)
+        deleted = True
+
+        # Clean up empty owner directory (only for structured layout)
+        if repo.owner:
+            owner_dir = ws.get_path() / repo.owner
+            if owner_dir.exists() and not any(owner_dir.iterdir()):
+                owner_dir.rmdir()
+
+    if output_json:
+        json.dump(
+            {"success": True, "repo": repo.key, "workspace": ws.label, "deleted_from_disk": deleted},
+            sys.stdout,
+            indent=2,
+        )
+        print()
+    else:
+        if deleted:
+            console.print(f"  [green]✓[/green] {repo.key} removed and deleted from disk.")
+        else:
+            console.print(f"  [green]✓[/green] {repo.key} removed from tracking.")
+            if path.exists():
+                console.print(f"  [dim]Files still at: {path}[/dim]")

gitstow/cli/search.py

@@ -0,0 +1,199 @@
+"""gitstow search — grep across all repos."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+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()
+err_console = Console(stderr=True)
+
+
+def search(
+    ctx: typer.Context,
+    pattern: str = typer.Argument(help="Search pattern (regex supported if using ripgrep)."),
+    tag: Optional[list[str]] = typer.Option(
+        None, "--tag", "-t", help="Only search in repos with this tag.",
+    ),
+    owner: Optional[str] = typer.Option(
+        None, "--owner", help="Only search in repos from this owner.",
+    ),
+    glob_filter: Optional[str] = typer.Option(
+        None, "--glob", "-g", help="File glob pattern (e.g., '*.py', '*.md').",
+    ),
+    case_insensitive: bool = typer.Option(
+        False, "--ignore-case", "-i", help="Case-insensitive search.",
+    ),
+    files_only: bool = typer.Option(
+        False, "--files", "-l", help="Only show file paths, not matching lines.",
+    ),
+    max_results: int = typer.Option(
+        50, "--max", "-m", help="Max results per repo.",
+    ),
+    output_json: bool = typer.Option(
+        False, "--json", "-j", help="JSON output.",
+    ),
+    quiet: bool = typer.Option(
+        False, "--quiet", "-q", help="Suppress headers.",
+    ),
+) -> None:
+    """[bold magenta]Search[/bold magenta] — grep across all repos.
+
+    Uses ripgrep (rg) if available, falls back to git grep.
+
+    \b
+    Examples:
+      gitstow search "TODO"
+      gitstow search "def main" --glob "*.py"
+      gitstow search "import React" --tag frontend
+      gitstow search -w active "error" -i --files
+    """
+    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 match the filter.[/dim]")
+        return
+
+    # Detect search tool
+    use_rg = _has_ripgrep()
+    all_results = []
+    total_matches = 0
+
+    for repo, ws in repo_ws_pairs:
+        path = repo.get_path(ws.get_path())
+        if not path.exists():
+            continue
+
+        matches = _search_repo(
+            path, pattern, use_rg,
+            glob_filter=glob_filter,
+            case_insensitive=case_insensitive,
+            files_only=files_only,
+            max_results=max_results,
+        )
+
+        if matches:
+            total_matches += len(matches)
+            repo_result = {
+                "repo": repo.key,
+                "matches": matches,
+                "count": len(matches),
+            }
+            all_results.append(repo_result)
+
+            if not output_json and not quiet:
+                console.print(f"\n  [bold]{repo.key}[/bold] [dim]({len(matches)} matches)[/dim]")
+                for match in matches:
+                    if files_only:
+                        console.print(f"    {match['file']}")
+                    else:
+                        console.print(f"    [dim]{match['file']}:{match.get('line_number', '')}:[/dim] {match.get('text', '')}")
+
+    if output_json:
+        json.dump({
+            "pattern": pattern,
+            "total_matches": total_matches,
+            "repos_with_matches": len(all_results),
+            "results": all_results,
+        }, sys.stdout, indent=2)
+        print()
+    elif not quiet:
+        if total_matches == 0:
+            console.print(f"\n  [dim]No matches for '{pattern}' across {len(repo_ws_pairs)} repos.[/dim]\n")
+        else:
+            console.print(f"\n  [green]{total_matches} matches[/green] across {len(all_results)} repos\n")
+
+
+def _has_ripgrep() -> bool:
+    """Check if ripgrep (rg) is available."""
+    import shutil
+    return shutil.which("rg") is not None
+
+
+def _search_repo(
+    path,
+    pattern: str,
+    use_rg: bool,
+    glob_filter: str | None = None,
+    case_insensitive: bool = False,
+    files_only: bool = False,
+    max_results: int = 50,
+) -> list[dict]:
+    """Search a single repo, return list of match dicts."""
+    if use_rg:
+        cmd = ["rg", "--no-heading", "--with-filename", "--line-number"]
+        if case_insensitive:
+            cmd.append("-i")
+        if files_only:
+            cmd.append("-l")
+        if glob_filter:
+            cmd.extend(["--glob", glob_filter])
+        cmd.extend(["--max-count", str(max_results)])
+        cmd.append(pattern)
+    else:
+        # Fall back to git grep
+        cmd = ["git", "grep", "-n"]
+        if case_insensitive:
+            cmd.append("-i")
+        if files_only:
+            cmd.append("-l")
+        cmd.extend(["--max-depth", "10"])
+        cmd.append(pattern)
+
+    try:
+        result = subprocess.run(
+            cmd,
+            cwd=path,
+            capture_output=True,
+            text=True,
+            timeout=30,
+            encoding="utf-8",
+            errors="replace",
+        )
+
+        if result.returncode not in (0, 1):  # 1 = no matches (normal)
+            return []
+
+        matches = []
+        for line in result.stdout.strip().splitlines():
+            if not line:
+                continue
+            if files_only:
+                matches.append({"file": line.strip()})
+            else:
+                # Parse file:line:text format
+                parts = line.split(":", 2)
+                if len(parts) >= 3:
+                    matches.append({
+                        "file": parts[0],
+                        "line_number": parts[1],
+                        "text": parts[2].strip(),
+                    })
+                elif len(parts) == 2:
+                    matches.append({"file": parts[0], "text": parts[1].strip()})
+                else:
+                    matches.append({"file": line, "text": ""})
+
+        return matches[:max_results]
+    except (subprocess.TimeoutExpired, Exception):
+        return []