gitstow 0.1.0__py3-none-any.whl

gitstow/cli/migrate.py

@@ -0,0 +1,142 @@
+"""gitstow migrate — adopt existing repos into the organized structure."""
+
+from __future__ import annotations
+
+import json
+import shutil
+import sys
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from gitstow.core.config import load_config
+from gitstow.core.git import is_git_repo, get_remote_url
+from gitstow.core.url_parser import parse_git_url
+from gitstow.core.repo import Repo, RepoStore
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+def migrate(
+    ctx: typer.Context,
+    paths: list[str] = typer.Argument(
+        help="Path(s) to existing git repos to adopt.",
+    ),
+    output_json: bool = typer.Option(
+        False, "--json", "-j", help="JSON output.",
+    ),
+    quiet: bool = typer.Option(
+        False, "--quiet", "-q", help="Suppress progress messages.",
+    ),
+) -> None:
+    """[bold]Migrate[/bold] existing repos into the gitstow structure.
+
+    Moves repos into the target workspace directory and registers them.
+    Uses the default workspace unless -w is specified.
+
+    \b
+    Examples:
+      gitstow migrate ~/old-projects/some-repo
+      gitstow migrate -w active ~/random-clones/repo1
+    """
+    settings = load_config()
+    store = RepoStore()
+    ws_label = (ctx.obj or {}).get("workspace")
+
+    from gitstow.cli.helpers import resolve_workspaces
+    ws_list = resolve_workspaces(settings, ws_label)
+    ws = ws_list[0]
+    root = ws.get_path()
+    results = []
+
+    for path_str in paths:
+        path = Path(path_str).expanduser().resolve()
+
+        if not path.exists():
+            results.append({"path": path_str, "status": "error", "detail": "Path does not exist"})
+            if not quiet:
+                err_console.print(f"  [red]✗[/red] {path_str}: path does not exist")
+            continue
+
+        if not is_git_repo(path):
+            results.append({"path": path_str, "status": "error", "detail": "Not a git repo"})
+            if not quiet:
+                err_console.print(f"  [red]✗[/red] {path_str}: not a git repo")
+            continue
+
+        remote_url = get_remote_url(path)
+        if not remote_url:
+            results.append({"path": path_str, "status": "error", "detail": "No remote URL configured"})
+            if not quiet:
+                err_console.print(f"  [red]✗[/red] {path_str}: no remote URL (can't determine owner/repo)")
+            continue
+
+        try:
+            parsed = parse_git_url(remote_url, default_host=settings.default_host)
+        except ValueError as e:
+            results.append({"path": path_str, "status": "error", "detail": f"Can't parse remote: {e}"})
+            if not quiet:
+                err_console.print(f"  [red]✗[/red] {path_str}: can't parse remote URL: {e}")
+            continue
+
+        # Determine target based on workspace layout
+        if ws.layout == "flat":
+            target = root / parsed.repo
+            repo_owner = ""
+        else:
+            target = root / parsed.owner / parsed.repo
+            repo_owner = parsed.owner
+
+        repo_key = f"{repo_owner}/{parsed.repo}" if repo_owner else parsed.repo
+
+        # Already in the right place?
+        if path == target:
+            repo = Repo(owner=repo_owner, name=parsed.repo, remote_url=remote_url, workspace=ws.label)
+            store.add(repo)
+            results.append({"path": path_str, "status": "registered", "key": repo_key})
+            if not quiet:
+                console.print(f"  [green]✓[/green] {repo_key} registered (already in place)")
+            continue
+
+        # Already tracked?
+        existing = store.get(repo_key, workspace=ws.label)
+        if existing:
+            results.append({"path": path_str, "status": "exists", "key": repo_key})
+            if not quiet:
+                console.print(f"  [yellow]○[/yellow] {repo_key} already tracked")
+            continue
+
+        # Target already exists?
+        if target.exists():
+            results.append({"path": path_str, "status": "conflict", "key": repo_key, "detail": f"Target exists: {target}"})
+            if not quiet:
+                err_console.print(f"  [red]✗[/red] {repo_key}: target path already exists: {target}")
+            continue
+
+        if not quiet:
+            console.print(f"  [dim]Moving[/dim] {path_str} → {target}...")
+
+        target.parent.mkdir(parents=True, exist_ok=True)
+
+        try:
+            path.rename(target)
+        except OSError:
+            shutil.copytree(path, target, symlinks=True)
+            shutil.rmtree(path)
+
+        repo = Repo(owner=repo_owner, name=parsed.repo, remote_url=remote_url, workspace=ws.label)
+        store.add(repo)
+        results.append({"path": path_str, "status": "migrated", "key": repo_key, "target": str(target)})
+        if not quiet:
+            console.print(f"  [green]✓[/green] {repo_key} migrated to {target}")
+
+    if output_json:
+        json.dump(results, sys.stdout, indent=2)
+        print()
+    elif not quiet and len(results) > 1:
+        migrated = sum(1 for r in results if r["status"] == "migrated")
+        registered = sum(1 for r in results if r["status"] == "registered")
+        errors = sum(1 for r in results if r["status"] in ("error", "conflict"))
+        console.print(f"\n  Done: {migrated} migrated, {registered} registered, {errors} errors\n")

gitstow/cli/onboard.py

@@ -0,0 +1,234 @@
+"""gitstow onboard — first-run setup wizard."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from beaupy import confirm as bconfirm, select as bselect
+from rich.console import Console
+from rich.panel import Panel
+
+from gitstow.core.config import Settings, Workspace, save_config
+from gitstow.core.paths import CONFIG_FILE, ensure_app_dirs, DEFAULT_ROOT
+from gitstow.core.git import is_git_installed
+from gitstow.core.discovery import discover_repos
+from gitstow.core.repo import Repo, RepoStore
+
+console = Console()
+
+
+HOST_OPTIONS = [
+    "[cyan]github.com[/cyan] — most common (default)",
+    "[cyan]gitlab.com[/cyan] — GitLab",
+    "[cyan]bitbucket.org[/cyan] — Bitbucket",
+    "[cyan]codeberg.org[/cyan] — Codeberg",
+    "[cyan]Custom[/cyan] — enter your own host",
+]
+HOST_VALUES = ["github.com", "gitlab.com", "bitbucket.org", "codeberg.org", "__custom__"]
+
+LAYOUT_OPTIONS = [
+    "[cyan]structured[/cyan] — owner/repo directories (e.g., anthropic/claude-code/)",
+    "[cyan]flat[/cyan] — repos directly in the workspace (e.g., claude-code/)",
+]
+LAYOUT_VALUES = ["structured", "flat"]
+
+
+def onboard(
+    force: bool = typer.Option(
+        False, "--force", "-f", help="Re-run setup even if already configured.",
+    ),
+) -> None:
+    """[bold]Set up[/bold] gitstow for first use.
+
+    Interactive wizard to configure workspaces, default host, and preferences.
+    """
+    if CONFIG_FILE.exists() and not force:
+        console.print(
+            "\n  [yellow]gitstow is already configured.[/yellow] "
+            "Use [bold]--force[/bold] to reconfigure.\n"
+        )
+        console.print(f"  Config: {CONFIG_FILE}")
+        console.print("  Run [bold]gitstow config show[/bold] to see current settings.\n")
+        return
+
+    # Welcome
+    console.print()
+    console.print(Panel(
+        "[bold]Welcome to gitstow![/bold]\n\n"
+        "A git repository manager — clone, organize, and maintain\n"
+        "collections of repos across multiple workspaces.\n\n"
+        "Let's set up your configuration.",
+        border_style="cyan",
+        padding=(1, 2),
+    ))
+    console.print()
+
+    # Check git
+    git_ok, git_version = is_git_installed()
+    if not git_ok:
+        console.print("  [red]✗ git is not installed.[/red] Please install git first.")
+        raise typer.Exit(code=1)
+    console.print(f"  [green]✓[/green] git {git_version} found\n")
+
+    settings = Settings()
+
+    # 1. First workspace
+    console.print("  [bold]1. Set up your first workspace[/bold]")
+    console.print("     A workspace is a directory where gitstow manages repos.\n")
+
+    ws = _setup_workspace(
+        default_path=str(DEFAULT_ROOT),
+        default_label="oss",
+        step_num=1,
+    )
+    settings.workspaces.append(ws)
+
+    # Offer to add more workspaces
+    console.print()
+    add_more = bconfirm("     Add another workspace? (e.g., for active projects)", default=False)
+    while add_more:
+        extra_ws = _setup_workspace(
+            default_path="",
+            default_label="",
+            step_num=None,
+        )
+        if extra_ws:
+            settings.workspaces.append(extra_ws)
+        add_more = bconfirm("     Add another workspace?", default=False)
+
+    # 2. Default host
+    console.print("\n  [bold]2. Default Git host[/bold] (used when you type 'owner/repo')")
+    console.print()
+    host_choice = bselect(HOST_OPTIONS, cursor=">>>", cursor_style="bold cyan")
+
+    if host_choice is None:
+        console.print("  [dim]Cancelled.[/dim]")
+        raise typer.Exit()
+
+    host_idx = HOST_OPTIONS.index(host_choice)
+    if HOST_VALUES[host_idx] == "__custom__":
+        custom_host = typer.prompt("     Enter your host", default="github.com")
+        settings.default_host = custom_host
+    else:
+        settings.default_host = HOST_VALUES[host_idx]
+    console.print(f"     → {settings.default_host}\n")
+
+    # 3. SSH preference
+    console.print("  [bold]3. Clone protocol preference[/bold]")
+    console.print()
+    prefer_ssh = bconfirm("     Prefer SSH over HTTPS?", default=False)
+    settings.prefer_ssh = prefer_ssh if prefer_ssh is not None else False
+    proto = "SSH" if settings.prefer_ssh else "HTTPS"
+    console.print(f"     → {proto}\n")
+
+    # Save config
+    ensure_app_dirs()
+    save_config(settings)
+    console.print(f"  [green]✓[/green] Config saved to {CONFIG_FILE}\n")
+
+    # 4. Create directories and scan
+    for ws in settings.workspaces:
+        ws_path = ws.get_path()
+        if not ws_path.exists():
+            create = bconfirm(f"     Create {ws_path}?", default=True)
+            if create:
+                ws_path.mkdir(parents=True, exist_ok=True)
+                console.print(f"  [green]✓[/green] Created {ws_path}")
+        if ws_path.exists():
+            _scan_workspace_repos(ws)
+
+    # 5. AI integration setup
+    from gitstow.cli.setup_ai import _setup_ai_integrations
+    _setup_ai_integrations()
+
+    # Done
+    ws_summary = ", ".join(f"[cyan]{ws.label}[/cyan]" for ws in settings.workspaces)
+    console.print(Panel(
+        "[bold green]Setup complete![/bold green]\n\n"
+        f"Workspaces: {ws_summary}\n\n"
+        "Quick start:\n"
+        "  [cyan]gitstow add owner/repo[/cyan]           Clone a repo\n"
+        "  [cyan]gitstow status[/cyan]                   Git status dashboard\n"
+        "  [cyan]gitstow status -w active[/cyan]         Status for one workspace\n"
+        "  [cyan]gitstow workspace list[/cyan]           See all workspaces\n"
+        "  [cyan]gitstow workspace add <path>[/cyan]     Add a new workspace\n\n"
+        "AI integration:\n"
+        "  Your AI tools are configured to manage repos for you.\n"
+        "  Re-run anytime with: [cyan]gitstow setup-ai[/cyan]",
+        border_style="green",
+        padding=(1, 2),
+    ))
+    console.print()
+
+
+def _setup_workspace(default_path: str, default_label: str, step_num: int | None) -> Workspace:
+    """Interactive setup for a single workspace."""
+    if default_path:
+        console.print(f"     Default path: [cyan]{default_path}[/cyan]")
+    path_input = typer.prompt(
+        "     Workspace path",
+        default=default_path or None,
+        show_default=False,
+    )
+    ws_path = Path(path_input).expanduser().resolve()
+
+    label_default = default_label or ws_path.name.lower()
+    label = typer.prompt("     Label", default=label_default, show_default=True)
+
+    console.print("\n     Directory layout:")
+    layout_choice = bselect(LAYOUT_OPTIONS, cursor=">>>", cursor_style="bold cyan")
+    layout = LAYOUT_VALUES[LAYOUT_OPTIONS.index(layout_choice)] if layout_choice else "structured"
+    console.print(f"     → {layout}\n")
+
+    auto_tags_input = typer.prompt(
+        "     Auto-tags (comma-separated, or empty)",
+        default="",
+        show_default=False,
+    )
+    auto_tags = [t.strip().lower() for t in auto_tags_input.split(",") if t.strip()]
+
+    return Workspace(
+        path=str(ws_path),
+        label=label,
+        layout=layout,
+        auto_tags=auto_tags,
+    )
+
+
+def _scan_workspace_repos(ws: Workspace) -> None:
+    """Scan a workspace for existing repos and offer to register them."""
+    console.print(f"\n  [bold]Scanning {ws.label} for existing repos...[/bold]")
+
+    store = RepoStore()
+    ws_path = ws.get_path()
+
+    found = discover_repos(ws_path, layout=ws.layout)
+    existing_keys = {r.key for r in store.list_by_workspace(ws.label)}
+    new_repos = [r for r in found if r.key not in existing_keys]
+
+    if not new_repos:
+        console.print("     [dim]No untracked repos found.[/dim]\n")
+        return
+
+    console.print(f"     Found {len(new_repos)} untracked repo{'s' if len(new_repos) != 1 else ''}:\n")
+    for dr in new_repos:
+        remote_short = dr.remote_url[:60] + "..." if dr.remote_url and len(dr.remote_url) > 60 else dr.remote_url or "[dim]no remote[/dim]"
+        console.print(f"       {dr.key}  [dim]({remote_short})[/dim]")
+
+    console.print()
+    register = bconfirm(f"     Register all {len(new_repos)} repos?", default=True)
+
+    if register:
+        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].\n")
+    else:
+        console.print("     [dim]Skipped. You can scan later with 'gitstow workspace scan'.[/dim]\n")

gitstow/cli/open_cmd.py

@@ -0,0 +1,144 @@
+"""gitstow open — open a repo in editor, browser, or Finder."""
+
+from __future__ import annotations
+
+import platform
+import subprocess
+import webbrowser
+
+import typer
+from rich.console import Console
+
+from gitstow.core.config import load_config
+from gitstow.core.git import get_remote_url
+from gitstow.core.repo import RepoStore
+from gitstow.cli.helpers import resolve_repo
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+def open_repo(
+    ctx: typer.Context,
+    repo_key: str = typer.Argument(help="Repo to open (owner/repo or name)."),
+    editor: bool = typer.Option(
+        False, "--editor", "-e", help="Open in default editor (VS Code, etc.).",
+    ),
+    browser: bool = typer.Option(
+        False, "--browser", "-b", help="Open on GitHub/GitLab in browser.",
+    ),
+    finder: bool = typer.Option(
+        False, "--finder", "-f", help="Open in Finder/file manager.",
+    ),
+    path_only: bool = typer.Option(
+        False, "--path", "-p", help="Just print the path (for cd, piping, etc.).",
+    ),
+) -> None:
+    """[bold]Open[/bold] a repo in your editor, browser, or file manager.
+
+    With no flags, opens in the default editor.
+
+    \b
+    Examples:
+      gitstow open anthropic/claude-code             # Default editor
+      gitstow open anthropic/claude-code --browser    # Open on GitHub
+      gitstow open anthropic/claude-code --finder     # Open in Finder
+      gitstow open anthropic/claude-code --path       # Print path
+      cd "$(gitstow open anthropic/claude-code -p)"   # cd into repo
+    """
+    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)
+    repo_path = repo.get_path(ws.get_path())
+
+    if not repo_path.exists():
+        err_console.print(f"[red]Error:[/red] '{repo_key}' not found on disk at {repo_path}")
+        raise typer.Exit(code=1)
+
+    # Print path mode
+    if path_only:
+        print(str(repo_path))
+        return
+
+    # Browser mode — open remote URL
+    if browser:
+        remote = get_remote_url(repo_path) or repo.remote_url
+        if remote:
+            web_url = _remote_to_web_url(remote)
+            webbrowser.open(web_url)
+            console.print(f"  [green]✓[/green] Opened {web_url}")
+        else:
+            err_console.print(f"[red]Error:[/red] No remote URL for {repo_key}")
+            raise typer.Exit(code=1)
+        return
+
+    # Finder mode
+    if finder:
+        _open_in_file_manager(repo_path)
+        console.print(f"  [green]✓[/green] Opened {repo_path} in file manager")
+        return
+
+    # Editor mode (default)
+    _open_in_editor(repo_path)
+    console.print(f"  [green]✓[/green] Opened {repo_key} in editor")
+
+
+def _remote_to_web_url(remote: str) -> str:
+    """Convert a git remote URL to a browser URL."""
+    url = remote.strip()
+
+    # SSH: git@github.com:owner/repo.git → https://github.com/owner/repo
+    if url.startswith("git@"):
+        url = url.replace(":", "/", 1).replace("git@", "https://")
+
+    # ssh:// scheme
+    if url.startswith("ssh://"):
+        url = url.replace("ssh://", "https://")
+        # Remove user@ if present
+        if "@" in url.split("/")[2]:
+            parts = url.split("/")
+            parts[2] = parts[2].split("@")[1]
+            url = "/".join(parts)
+
+    # Strip .git suffix
+    if url.endswith(".git"):
+        url = url[:-4]
+
+    # Ensure https://
+    if not url.startswith("http"):
+        url = f"https://{url}"
+
+    return url
+
+
+def _open_in_editor(path) -> None:
+    """Open a directory in the default editor."""
+    import os
+    import shutil
+
+    # Try common editors in order
+    editor = os.environ.get("EDITOR") or os.environ.get("VISUAL")
+
+    if shutil.which("code"):
+        subprocess.Popen(["code", str(path)], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    elif shutil.which("cursor"):
+        subprocess.Popen(["cursor", str(path)], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    elif editor:
+        subprocess.Popen([editor, str(path)])
+    elif platform.system() == "Darwin":
+        subprocess.Popen(["open", "-a", "TextEdit", str(path)])
+    else:
+        subprocess.Popen(["xdg-open", str(path)])
+
+
+def _open_in_file_manager(path) -> None:
+    """Open a directory in the system file manager."""
+    system = platform.system()
+    if system == "Darwin":
+        subprocess.Popen(["open", str(path)])
+    elif system == "Windows":
+        subprocess.Popen(["explorer", str(path)])
+    else:
+        subprocess.Popen(["xdg-open", str(path)])