gitstow 0.1.0__py3-none-any.whl

gitstow/cli/exec_cmd.py

@@ -0,0 +1,159 @@
+"""gitstow exec — run arbitrary commands across 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.core.parallel import run_parallel_sync
+from gitstow.cli.helpers import iter_repos_with_workspace
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+def _exec_in_repo(repo_path, command: list[str]) -> dict:
+    """Execute a command in a repo directory."""
+    try:
+        result = subprocess.run(
+            command,
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+            timeout=120,
+            encoding="utf-8",
+            errors="replace",
+        )
+        return {
+            "returncode": result.returncode,
+            "stdout": result.stdout.strip(),
+            "stderr": result.stderr.strip(),
+        }
+    except subprocess.TimeoutExpired:
+        return {"returncode": -1, "stdout": "", "stderr": "Command timed out (2 minutes)"}
+    except Exception as e:
+        return {"returncode": -1, "stdout": "", "stderr": str(e)}
+
+
+def exec_cmd(
+    ctx: typer.Context,
+    command: list[str] = typer.Argument(
+        help="Command to run in each repo (e.g., 'git log -1 --oneline').",
+    ),
+    tag: Optional[list[str]] = typer.Option(
+        None, "--tag", "-t", help="Only run in repos with this tag.",
+    ),
+    owner: Optional[str] = typer.Option(
+        None, "--owner", help="Only run in repos from this owner.",
+    ),
+    frozen_only: bool = typer.Option(
+        False, "--frozen", help="Only run in frozen repos.",
+    ),
+    output_json: bool = typer.Option(
+        False, "--json", "-j", help="JSON output.",
+    ),
+    quiet: bool = typer.Option(
+        False, "--quiet", "-q", help="Only show output, no headers.",
+    ),
+    sequential: bool = typer.Option(
+        False, "--sequential", "-s", help="Run sequentially instead of in parallel.",
+    ),
+) -> None:
+    """[bold]Exec[/bold] — run a command in every repo.
+
+    The command is run with CWD set to each repo's directory.
+
+    \b
+    Examples:
+      gitstow exec git log -1 --oneline
+      gitstow exec -- git branch --show-current
+      gitstow exec --tag ai -- wc -l README.md
+      gitstow exec -w active -- ls -la
+    """
+    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 not repo_ws_pairs:
+        if not quiet:
+            console.print("[dim]No repos match the filter.[/dim]")
+        return
+
+    if not command:
+        err_console.print("[red]Error:[/red] No command specified.")
+        raise typer.Exit(code=1)
+
+    results = []
+
+    if sequential:
+        for repo, ws in repo_ws_pairs:
+            path = repo.get_path(ws.get_path())
+            if not path.exists():
+                results.append({"repo": repo.key, "returncode": -1, "stdout": "", "stderr": "Not found on disk"})
+                continue
+            result = _exec_in_repo(path, command)
+            result["repo"] = repo.key
+            results.append(result)
+
+            if not output_json and not quiet:
+                _print_repo_result(repo.key, result)
+    else:
+        tasks = [
+            (repo.global_key, lambda r=repo, w=ws: _exec_in_repo(r.get_path(w.get_path()), command))
+            for repo, ws in repo_ws_pairs
+        ]
+        task_results = run_parallel_sync(tasks, max_concurrent=settings.parallel_limit)
+
+        for task_result in task_results:
+            if task_result.success and task_result.data:
+                entry = task_result.data
+                entry["repo"] = task_result.key
+            else:
+                entry = {"repo": task_result.key, "returncode": -1, "stdout": "", "stderr": task_result.error}
+            results.append(entry)
+
+        if not output_json:
+            for r in sorted(results, key=lambda x: x["repo"]):
+                if not quiet:
+                    _print_repo_result(r["repo"], r)
+                elif r["stdout"]:
+                    console.print(r["stdout"])
+
+    if output_json:
+        json.dump(results, sys.stdout, indent=2)
+        print()
+
+    # Exit with error if any command failed
+    if any(r["returncode"] != 0 for r in results):
+        raise typer.Exit(code=1)
+
+
+def _print_repo_result(repo_key: str, result: dict) -> None:
+    """Print a single repo's exec result."""
+    rc = result["returncode"]
+    status = "[green]✓[/green]" if rc == 0 else f"[red]✗ (exit {rc})[/red]"
+    console.print(f"\n  [bold]{repo_key}[/bold] {status}")
+
+    if result["stdout"]:
+        for line in result["stdout"].splitlines():
+            console.print(f"    {line}")
+    if result["stderr"] and result["returncode"] != 0:
+        for line in result["stderr"].splitlines():
+            err_console.print(f"    [dim]{line}[/dim]")

gitstow/cli/export_cmd.py

@@ -0,0 +1,293 @@
+"""gitstow export / import — share repo collections."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import Optional
+
+import typer
+import yaml
+from rich.console import Console
+
+from gitstow.core.config import load_config
+from gitstow.core.repo import Repo, RepoStore
+
+export_app = typer.Typer(
+    help="Export and import repo collections.",
+    no_args_is_help=True,
+)
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+@export_app.command("export")
+def export_collection(
+    ctx: typer.Context,
+    output: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output file path. Defaults to stdout.",
+    ),
+    tag: Optional[list[str]] = typer.Option(
+        None, "--tag", "-t", help="Only export repos with this tag.",
+    ),
+    format_type: str = typer.Option(
+        "yaml", "--format", "-f", help="Output format: yaml, json, or urls.",
+    ),
+) -> None:
+    """[bold]Export[/bold] your repo collection to a portable file.
+
+    \b
+    Formats:
+      yaml  — Full metadata (default). Can be imported back.
+      json  — Full metadata as JSON.
+      urls  — Plain list of clone URLs (one per line).
+
+    \b
+    Examples:
+      gitstow collection export                       # YAML to stdout
+      gitstow collection export -o my-repos.yaml      # YAML to file
+      gitstow collection export --format urls          # Just URLs
+      gitstow collection export --tag ai -o ai.yaml    # Export subset
+    """
+    store = RepoStore()
+    ws_label = (ctx.obj or {}).get("workspace")
+
+    if ws_label:
+        repos = store.list_by_workspace(ws_label)
+    else:
+        repos = store.list_all()
+
+    if tag:
+        tag_set = set(tag)
+        repos = [r for r in repos if tag_set.intersection(r.tags)]
+
+    if not repos:
+        err_console.print("[dim]No repos to export.[/dim]")
+        return
+
+    if format_type == "urls":
+        lines = [r.remote_url for r in repos]
+        content = "\n".join(lines) + "\n"
+    elif format_type == "json":
+        data = {
+            "version": 1,
+            "repos": [
+                {
+                    "key": r.key,
+                    "workspace": r.workspace,
+                    "remote_url": r.remote_url,
+                    "tags": r.tags,
+                    "frozen": r.frozen,
+                }
+                for r in repos
+            ],
+        }
+        content = json.dumps(data, indent=2) + "\n"
+    else:  # yaml
+        repos_data = {}
+        for r in repos:
+            entry = {"remote_url": r.remote_url}
+            if r.workspace:
+                entry["workspace"] = r.workspace
+            if r.tags:
+                entry["tags"] = r.tags
+            if r.frozen:
+                entry["frozen"] = True
+            repos_data[r.key] = entry
+        data = {"version": 1, "repos": repos_data}
+        content = yaml.dump(data, default_flow_style=False, sort_keys=False)
+
+    if output:
+        Path(output).write_text(content)
+        console.print(f"  [green]✓[/green] Exported {len(repos)} repos to {output}")
+    else:
+        sys.stdout.write(content)
+
+
+@export_app.command("import")
+def import_collection(
+    ctx: typer.Context,
+    file_path: str = typer.Argument(help="File to import (YAML, JSON, or plain URLs)."),
+    tag: Optional[list[str]] = typer.Option(
+        None, "--tag", "-t", help="Apply tag(s) to all imported repos.",
+    ),
+    shallow: bool = typer.Option(
+        False, "--shallow", "-s", help="Shallow clone imported repos.",
+    ),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", "-n", help="Show what would be imported without doing it.",
+    ),
+) -> None:
+    """[bold]Import[/bold] a repo collection from a file.
+
+    Supports YAML (from gitstow export), JSON, or a plain list of URLs.
+    Repos that already exist are skipped.
+
+    \b
+    Examples:
+      gitstow collection import my-repos.yaml
+      gitstow collection import repos.txt --shallow
+      gitstow collection import ai-repos.yaml --tag ai --dry-run
+    """
+    path = Path(file_path)
+    if not path.exists():
+        err_console.print(f"[red]Error:[/red] File not found: {file_path}")
+        raise typer.Exit(code=1)
+
+    content = path.read_text()
+    tags = list(tag) if tag else []
+
+    # Detect format
+    repos_to_import = _parse_import_file(content, path.suffix)
+
+    if not repos_to_import:
+        err_console.print("[dim]No repos found in file.[/dim]")
+        return
+
+    store = RepoStore()
+
+    # Check which already exist
+    new_repos = []
+    existing = []
+    for entry in repos_to_import:
+        if store.get(entry.get("key", "")):
+            existing.append(entry)
+        else:
+            new_repos.append(entry)
+
+    console.print(f"\n  Found {len(repos_to_import)} repos in file")
+    if existing:
+        console.print(f"  [dim]{len(existing)} already tracked (will skip)[/dim]")
+    console.print(f"  {len(new_repos)} new repos to import\n")
+
+    if dry_run:
+        for entry in new_repos:
+            console.print(f"    [dim]Would add:[/dim] {entry.get('key', entry.get('url', 'unknown'))}")
+        console.print("\n  [dim]Dry run — nothing was changed.[/dim]\n")
+        return
+
+    if not new_repos:
+        console.print("  [dim]Nothing new to import.[/dim]\n")
+        return
+
+    # Build add commands
+    from gitstow.core.url_parser import parse_git_url
+    from gitstow.core.git import clone as git_clone
+    from gitstow.cli.helpers import resolve_workspaces
+    from datetime import datetime
+
+    settings = load_config()
+    ws_label = (ctx.obj or {}).get("workspace")
+    ws_list = resolve_workspaces(settings, ws_label)
+    ws = ws_list[0]
+    root = ws.get_path()
+    succeeded = 0
+    failed = 0
+
+    for entry in new_repos:
+        url = entry.get("url") or entry.get("remote_url", "")
+        entry_tags = entry.get("tags", []) + tags + list(ws.auto_tags)
+        frozen = entry.get("frozen", False)
+
+        try:
+            parsed = parse_git_url(url, default_host=settings.default_host, prefer_ssh=settings.prefer_ssh)
+        except ValueError as e:
+            err_console.print(f"  [red]✗[/red] {url}: {e}")
+            failed += 1
+            continue
+
+        if ws.layout == "flat":
+            target = root / parsed.repo
+            repo_owner = ""
+        else:
+            target = root / parsed.owner / parsed.repo
+            repo_owner = parsed.owner
+
+        if target.exists():
+            console.print(f"  [yellow]○[/yellow] {parsed.key} already on disk, registering")
+            repo = Repo(owner=repo_owner, name=parsed.repo, remote_url=url, workspace=ws.label, tags=entry_tags, frozen=frozen)
+            store.add(repo)
+            succeeded += 1
+            continue
+
+        console.print(f"  [dim]Cloning[/dim] {parsed.key}...")
+        target.parent.mkdir(parents=True, exist_ok=True)
+
+        success, error = git_clone(url=parsed.clone_url, target=target, shallow=shallow)
+        if success:
+            repo = Repo(
+                owner=repo_owner,
+                name=parsed.repo,
+                remote_url=parsed.clone_url,
+                workspace=ws.label,
+                tags=entry_tags,
+                frozen=frozen,
+                last_pulled=datetime.now().isoformat(),
+            )
+            store.add(repo)
+            console.print(f"  [green]✓[/green] {parsed.key}")
+            succeeded += 1
+        else:
+            err_console.print(f"  [red]✗[/red] {parsed.key}: {error}")
+            failed += 1
+
+    console.print(f"\n  Done: {succeeded} imported", end="")
+    if failed:
+        console.print(f", [red]{failed} failed[/red]", end="")
+    console.print("\n")
+
+
+EXPORT_FORMAT_VERSION = 1
+
+
+def _parse_import_file(content: str, suffix: str) -> list[dict]:
+    """Parse an import file into a list of repo dicts.
+
+    Supports versioned format (version: 1) and legacy unversioned format.
+    """
+    # Try YAML first
+    if suffix in (".yaml", ".yml"):
+        data = yaml.safe_load(content)
+        if isinstance(data, dict):
+            # Versioned format: {"version": 1, "repos": {...}}
+            if "version" in data and "repos" in data:
+                version = data["version"]
+                if version > EXPORT_FORMAT_VERSION:
+                    raise typer.Exit(code=1)  # Caller should print error
+                repos_data = data["repos"]
+                if isinstance(repos_data, dict):
+                    return [
+                        {"key": k, "url": v.get("remote_url", ""), "tags": v.get("tags", []), "frozen": v.get("frozen", False)}
+                        for k, v in repos_data.items()
+                        if isinstance(v, dict)
+                    ]
+            # Legacy unversioned format: {key: {remote_url: ...}}
+            return [
+                {"key": k, "url": v.get("remote_url", ""), "tags": v.get("tags", []), "frozen": v.get("frozen", False)}
+                for k, v in data.items()
+                if isinstance(v, dict)
+            ]
+        elif isinstance(data, list):
+            return [{"url": item} if isinstance(item, str) else item for item in data]
+
+    # Try JSON
+    if suffix == ".json":
+        data = json.loads(content)
+        # Versioned format: {"version": 1, "repos": [...]}
+        if isinstance(data, dict) and "version" in data and "repos" in data:
+            version = data["version"]
+            if version > EXPORT_FORMAT_VERSION:
+                raise typer.Exit(code=1)
+            data = data["repos"]
+        if isinstance(data, list):
+            return [
+                {"key": item.get("key", ""), "url": item.get("remote_url", item.get("url", "")), "tags": item.get("tags", []), "frozen": item.get("frozen", False)}
+                for item in data
+                if isinstance(item, dict)
+            ]
+
+    # Plain text: one URL per line
+    lines = [line.strip() for line in content.splitlines() if line.strip() and not line.startswith("#")]
+    return [{"url": line} for line in lines]

gitstow/cli/helpers.py

@@ -0,0 +1,113 @@
+"""Shared CLI helpers for workspace resolution and repo lookup."""
+
+from __future__ import annotations
+
+import sys
+
+import typer
+from rich.console import Console
+
+from gitstow.core.config import Settings, Workspace
+from gitstow.core.repo import Repo, RepoStore
+
+err_console = Console(stderr=True)
+
+
+def resolve_workspaces(
+    settings: Settings,
+    workspace_label: str | None = None,
+) -> list[Workspace]:
+    """Return workspaces filtered by label, or all if label is None."""
+    all_ws = settings.get_workspaces()
+    if workspace_label is None:
+        return all_ws
+    ws = settings.get_workspace(workspace_label)
+    if ws is None:
+        labels = ", ".join(w.label for w in all_ws)
+        err_console.print(
+            f"[red]Error:[/red] Unknown workspace [bold]{workspace_label}[/bold]. "
+            f"Available: {labels}"
+        )
+        raise typer.Exit(code=1)
+    return [ws]
+
+
+def get_workspace_for_repo(
+    repo: Repo,
+    settings: Settings,
+) -> Workspace | None:
+    """Look up the workspace a repo belongs to."""
+    return settings.get_workspace(repo.workspace)
+
+
+def resolve_repo(
+    store: RepoStore,
+    settings: Settings,
+    key: str,
+    workspace_label: str | None = None,
+) -> tuple[Repo, Workspace]:
+    """Find a repo by key, prompting interactively if ambiguous.
+
+    Returns (repo, workspace) or exits with error.
+    """
+    if workspace_label:
+        repo = store.get(key, workspace=workspace_label)
+        if repo is None:
+            err_console.print(
+                f"[red]Error:[/red] Repo [bold]{key}[/bold] not found "
+                f"in workspace [bold]{workspace_label}[/bold]."
+            )
+            raise typer.Exit(code=1)
+        ws = settings.get_workspace(workspace_label)
+        return repo, ws
+
+    # Try unique resolution
+    matches = store.find_all(key)
+    if len(matches) == 0:
+        err_console.print(f"[red]Error:[/red] Repo [bold]{key}[/bold] not found.")
+        raise typer.Exit(code=1)
+    if len(matches) == 1:
+        ws = settings.get_workspace(matches[0].workspace)
+        return matches[0], ws
+
+    # Ambiguous — prompt if interactive, error if piped
+    if not sys.stdin.isatty():
+        ws_labels = ", ".join(r.workspace for r in matches)
+        err_console.print(
+            f"[red]Error:[/red] Repo [bold]{key}[/bold] exists in multiple workspaces: "
+            f"{ws_labels}. Use [bold]--workspace[/bold] to disambiguate."
+        )
+        raise typer.Exit(code=1)
+
+    # Interactive prompt
+    from beaupy import select as bselect
+    options = [
+        f"[cyan]{r.workspace}[/cyan] — {r.get_path(settings.get_workspace(r.workspace).get_path())}"
+        for r in matches
+    ]
+    err_console.print(
+        f"\n  Repo [bold]{key}[/bold] found in {len(matches)} workspaces:\n"
+    )
+    choice = bselect(options, cursor=">>>", cursor_style="bold cyan")
+    if choice is None:
+        raise typer.Exit()
+    idx = options.index(choice)
+    repo = matches[idx]
+    ws = settings.get_workspace(repo.workspace)
+    return repo, ws
+
+
+def iter_repos_with_workspace(
+    store: RepoStore,
+    settings: Settings,
+    workspace_label: str | None = None,
+) -> list[tuple[Repo, Workspace]]:
+    """Iterate all repos paired with their workspace, optionally filtered."""
+    workspaces = resolve_workspaces(settings, workspace_label)
+    ws_map = {ws.label: ws for ws in workspaces}
+
+    result = []
+    for repo in store.list_all():
+        if repo.workspace in ws_map:
+            result.append((repo, ws_map[repo.workspace]))
+    return result