gwitch 0.1.0__py3-none-any.whl

gw/cli.py

@@ -0,0 +1,30 @@
+import typer
+
+from gw.commands.account import account_app
+from gw.commands.credential_helper import credential_helper_command
+from gw.commands.init_cmd import init_command
+from gw.commands.status import status_command
+from gw.commands.use import use_command
+
+app = typer.Typer(
+    name="gw",
+    help="Switch between git/GitHub accounts per repository.",
+    no_args_is_help=True,
+)
+app.add_typer(account_app, name="account")
+app.command("use")(use_command)
+app.command("status")(status_command)
+app.command("whoami")(status_command)
+app.command("init")(init_command)
+app.command(
+    "credential-helper",
+    help="Internal: invoked by git as this repo's HTTPS credential helper. Not meant to be run directly.",
+)(credential_helper_command)
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

gw/commands/account.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import typer
+
+from gw import config, gh_ops, ssh_ops
+
+account_app = typer.Typer(help="Manage gw accounts.")
+
+_NAME_RE = re.compile(r"^[A-Za-z0-9._-]+$")
+
+
+@account_app.command("add")
+def add(name: str, force: bool = typer.Option(False, "--force", help="Overwrite an existing account")) -> None:
+    if not _NAME_RE.match(name):
+        typer.echo(
+            f"Error: invalid account name '{name}'. "
+            "Names may only contain letters, numbers, '.', '_', and '-'.",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    config_path = config.default_config_path()
+    if not force:
+        try:
+            existing_names = {a.name for a in config.load_accounts(config_path)}
+        except config.ConfigError as e:
+            typer.echo(f"Error: {e}", err=True)
+            raise typer.Exit(code=1)
+        if name in existing_names:
+            typer.echo(f"Error: account '{name}' already exists. Use --force to overwrite.", err=True)
+            raise typer.Exit(code=1)
+
+    git_name = typer.prompt("Git user.name")
+    git_email = typer.prompt("Git user.email")
+    gh_username = typer.prompt("GitHub username")
+    gh_host = typer.prompt("GitHub host", default="github.com")
+
+    generate = typer.confirm(f"Generate a new SSH key for '{name}'?", default=True)
+    if generate:
+        ssh_key = str(Path.home() / ".ssh" / f"id_ed25519_{name}")
+        if ssh_ops.key_exists(ssh_key):
+            typer.echo(f"Key already exists at {ssh_key}, using existing key.")
+        else:
+            try:
+                ssh_ops.generate_key(ssh_key, git_email)
+            except ssh_ops.SshOpsError as e:
+                typer.echo(f"Error: could not generate SSH key: {e}", err=True)
+                raise typer.Exit(code=1)
+        pub = ssh_ops.read_public_key(ssh_ops.public_key_path(ssh_key))
+        typer.echo(f"Public key (add this at https://github.com/settings/keys):\n{pub}")
+    else:
+        ssh_key = typer.prompt("Path to existing private SSH key")
+        if not ssh_ops.key_exists(ssh_key):
+            typer.echo(f"Error: no key found at {ssh_key}", err=True)
+            raise typer.Exit(code=1)
+
+    account = config.Account(
+        name=name,
+        git_name=git_name,
+        git_email=git_email,
+        ssh_key=ssh_key,
+        gh_host=gh_host,
+        gh_username=gh_username,
+    )
+
+    try:
+        config.add_account(config_path, account, force=force)
+    except config.AccountExistsError:
+        typer.echo(f"Error: account '{name}' already exists. Use --force to overwrite.", err=True)
+        raise typer.Exit(code=1)
+    except config.ConfigError as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+    typer.echo(f"Account '{name}' added.")
+
+    if gh_ops.is_gh_installed():
+        if typer.confirm(f"Run 'gh auth login' now to authenticate '{gh_username}'?", default=False):
+            gh_ops.auth_login(gh_host)
+    else:
+        typer.echo("Note: gh CLI not found — skipping GitHub CLI auth setup.")
+
+
+@account_app.command("list")
+def list_accounts() -> None:
+    try:
+        accounts = config.load_accounts(config.default_config_path())
+    except config.ConfigError as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1)
+    if not accounts:
+        typer.echo("No accounts configured. Add one with `gw account add <name>`.")
+        return
+    for a in accounts:
+        typer.echo(f"{a.name}\t{a.git_email}\t{a.ssh_key}\t{a.gh_username}@{a.gh_host}")
+
+
+@account_app.command("remove")
+def remove(name: str) -> None:
+    try:
+        config.remove_account(config.default_config_path(), name)
+    except config.AccountNotFoundError:
+        typer.echo(f"Error: no account named '{name}'.", err=True)
+        raise typer.Exit(code=1)
+    except config.ConfigError as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1)
+    typer.echo(f"Account '{name}' removed.")

gw/commands/credential_helper.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import sys
+
+import typer
+
+from gw import config, gh_ops, git_ops
+
+
+def credential_helper_command(operation: str) -> None:
+    raw_input = sys.stdin.read()
+
+    if operation != "get":
+        return
+
+    request = _parse_credential_input(raw_input)
+
+    account_name = git_ops.get_local_config("gw.account")
+    if not account_name:
+        return
+
+    try:
+        account = config.get_account(config.default_config_path(), account_name)
+    except config.ConfigError:
+        return
+
+    requested_host = request.get("host")
+    if requested_host and requested_host != account.gh_host:
+        return
+
+    if not gh_ops.is_gh_installed():
+        return
+
+    token = gh_ops.get_token(account.gh_host, account.gh_username)
+    if not token:
+        return
+
+    typer.echo(f"username={account.gh_username}")
+    typer.echo(f"password={token}")
+
+
+def _parse_credential_input(raw: str) -> dict[str, str]:
+    parsed: dict[str, str] = {}
+    for line in raw.splitlines():
+        if not line or "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        parsed[key] = value
+    return parsed

gw/commands/init_cmd.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import typer
+
+from gw import prompt_install, remote_check_install
+
+SNIPPETS = {
+    "zsh": (
+        'gw_prompt() {\n'
+        '  local acct\n'
+        '  acct=$(git config --local --get gw.account 2>/dev/null)\n'
+        '  [[ -n "$acct" ]] && printf \'[%s]\' "$acct"\n'
+        '  return 0\n'
+        '}'
+    ),
+    "bash": (
+        'gw_prompt() {\n'
+        '  local acct\n'
+        '  acct=$(git config --local --get gw.account 2>/dev/null)\n'
+        '  [[ -n "$acct" ]] && printf \'[%s]\' "$acct"\n'
+        '  return 0\n'
+        '}'
+    ),
+    "fish": (
+        'function gw_prompt\n'
+        '    set -l acct (git config --local --get gw.account 2>/dev/null)\n'
+        '    if test -n "$acct"\n'
+        '        printf \'[%s]\' "$acct"\n'
+        '    end\n'
+        'end'
+    ),
+}
+
+INSTRUCTIONS = {
+    "zsh": (
+        "Add to ~/.zshrc (along with 'setopt PROMPT_SUBST' if not already set), "
+        "then reference $(gw_prompt) in your PROMPT/PS1."
+    ),
+    "bash": "Add to ~/.bashrc, then reference $(gw_prompt) in your PS1.",
+    "fish": (
+        "Add to ~/.config/fish/functions/gw_prompt.fish (or config.fish), "
+        "then reference (gw_prompt) in your fish_prompt function."
+    ),
+}
+
+INSTALLABLE_SHELLS = {"zsh", "bash"}
+
+
+def init_command(
+    shell: str,
+    install: bool = typer.Option(
+        False,
+        "--install",
+        help="Write the gw-prompt and gw-check scripts to disk and wire them into your shell rc file.",
+    ),
+) -> None:
+    shell = shell.lower()
+    if shell not in SNIPPETS:
+        supported = ", ".join(SNIPPETS)
+        typer.echo(f"Error: unsupported shell '{shell}'. Supported: {supported}", err=True)
+        raise typer.Exit(code=1)
+
+    if install:
+        if shell not in INSTALLABLE_SHELLS:
+            typer.echo(
+                f"Error: --install is not supported for {shell} yet — run "
+                f"`gw init {shell}` to see the manual setup instructions instead.",
+                err=True,
+            )
+            raise typer.Exit(code=1)
+
+        try:
+            prompt_result = prompt_install.install(shell)
+            check_result = remote_check_install.install_check(shell)
+        except prompt_install.PromptInstallError as e:
+            typer.echo(f"Error: {e}", err=True)
+            raise typer.Exit(code=1)
+
+        if prompt_result.newly_installed:
+            typer.echo(f"Installed gw-prompt script to {prompt_result.script_path}")
+        if check_result.newly_installed:
+            typer.echo(f"Installed gw-check script to {check_result.script_path}")
+
+        if prompt_result.newly_installed:
+            typer.echo(f"Added prompt integration to {prompt_result.rc_path}")
+        else:
+            typer.echo(
+                f"gw-prompt script refreshed at {prompt_result.script_path}; "
+                f"prompt integration already present in {prompt_result.rc_path}."
+            )
+
+        if check_result.newly_installed:
+            typer.echo(f"Added remote-account check to {check_result.rc_path}")
+        else:
+            typer.echo(
+                f"gw-check script refreshed at {check_result.script_path}; "
+                f"remote-account check already present in {check_result.rc_path}."
+            )
+
+        if prompt_result.newly_installed or check_result.newly_installed:
+            typer.echo(
+                f"Restart your shell (or run: source {prompt_result.rc_path}) to see it take effect."
+            )
+        return
+
+    typer.echo(SNIPPETS[shell])
+    typer.echo()
+    typer.echo(f"# {INSTRUCTIONS[shell]}")

gw/commands/status.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import typer
+
+from gw import config, gh_ops, git_ops
+
+
+def status_command() -> None:
+    if not git_ops.is_inside_work_tree():
+        typer.echo("Error: not inside a git repository.", err=True)
+        raise typer.Exit(code=1)
+
+    account_name = git_ops.get_local_config("gw.account")
+    if not account_name:
+        typer.echo("No gw account set for this repo. Run `gw use <name>`.")
+        return
+
+    git_name = git_ops.get_local_config("user.name") or "(unset)"
+    git_email = git_ops.get_local_config("user.email") or "(unset)"
+    ssh_cmd = git_ops.get_local_config("core.sshCommand") or "(unset)"
+
+    typer.echo(f"Repo account: {account_name}")
+    typer.echo(f"  user.name:  {git_name}")
+    typer.echo(f"  user.email: {git_email}")
+    typer.echo(f"  sshCommand: {ssh_cmd}")
+
+    try:
+        account = config.get_account(config.default_config_path(), account_name)
+    except config.AccountNotFoundError:
+        typer.echo(f"Warning: '{account_name}' is not in the account config (was it removed?).")
+        return
+    except config.ConfigError as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+    cred_helper = git_ops.get_local_config(f"credential.https://{account.gh_host}.helper") or "(unset)"
+    typer.echo(f"  credHelper: {cred_helper}")
+
+    if not gh_ops.is_gh_installed():
+        typer.echo("gh account:  gh CLI not installed")
+        return
+
+    gh_active = gh_ops.current_account(account.gh_host)
+    if gh_active is None:
+        typer.echo(
+            f"gh account:  could not determine (not logged in to {account.gh_host}, "
+            "or the gh API call failed)"
+        )
+    elif gh_active == account.gh_username:
+        typer.echo(f"gh account:  {gh_active} (matches)")
+    else:
+        typer.echo(
+            f"gh account:  {gh_active} (WARNING: expected '{account.gh_username}' — "
+            f"gh auth is global; run `gw use {account_name}` again or `gh auth switch` manually)"
+        )

gw/commands/use.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import typer
+
+from gw import config, gh_ops, git_ops, ssh_ops
+
+
+def use_command(name: str) -> None:
+    if not git_ops.is_inside_work_tree():
+        typer.echo("Error: not inside a git repository.", err=True)
+        raise typer.Exit(code=1)
+
+    if git_ops.is_linked_worktree():
+        typer.echo(
+            "Warning: this is a linked git worktree — 'gw use' here changes git "
+            "identity for the main checkout and all sibling worktrees too (git "
+            "shares local config across worktrees by default), not just this one.",
+            err=True,
+        )
+
+    try:
+        account = config.get_account(config.default_config_path(), name)
+    except config.AccountNotFoundError:
+        accounts = config.load_accounts(config.default_config_path())
+        names = ", ".join(a.name for a in accounts) or "(none configured)"
+        typer.echo(f"Error: no account named '{name}'. Available: {names}", err=True)
+        raise typer.Exit(code=1)
+    except config.ConfigError as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+    if not ssh_ops.key_exists(account.ssh_key):
+        typer.echo(f"Error: SSH key not found at {account.ssh_key}", err=True)
+        raise typer.Exit(code=1)
+
+    # Write the gw.account marker first: if a later write in this sequence
+    # fails, the marker at least reflects the attempted target rather than
+    # silently keeping the stale previous account, and the explicit error
+    # below makes the partial state impossible to miss.
+    try:
+        git_ops.set_local_config("gw.account", account.name)
+        git_ops.set_local_config("user.name", account.git_name)
+        git_ops.set_local_config("user.email", account.git_email)
+        git_ops.set_local_config("core.sshCommand", git_ops.ssh_command_for_key(account.ssh_key))
+        git_ops.set_local_credential_helper(account.gh_host)
+    except git_ops.GitOpsError as e:
+        typer.echo(
+            f"Error: failed to update git config while switching to '{account.name}': {e}\n"
+            "This repo may now be in a partially-switched state. Re-run "
+            f"`gw use {account.name}` to retry.",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    typer.echo(f"Switched to '{account.name}' ({account.git_email}) for this repo.")
+
+    remote_url = git_ops.get_remote_url()
+    if remote_url:
+        try:
+            git_ops.record_remote_account(remote_url, account.name)
+        except git_ops.GitOpsError as e:
+            typer.echo(
+                f"Warning: could not record this repo's remote for future account checks: {e}",
+                err=True,
+            )
+
+    if account.gh_username:
+        if gh_ops.is_gh_installed():
+            try:
+                gh_ops.auth_switch(account.gh_host, account.gh_username)
+                typer.echo(
+                    f"gh CLI switched to '{account.gh_username}' "
+                    "(note: this is global, not per-repo)."
+                )
+            except gh_ops.GhOpsError:
+                typer.echo(
+                    f"Warning: could not switch gh CLI to '{account.gh_username}'. "
+                    f"Run `gh auth login --hostname {account.gh_host}` first.",
+                    err=True,
+                )
+        else:
+            typer.echo("Note: gh CLI not found — skipping gh CLI account switch.")

gw/config.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+import toml
+
+
+class ConfigError(Exception):
+    pass
+
+
+class AccountExistsError(ConfigError):
+    pass
+
+
+class AccountNotFoundError(ConfigError):
+    pass
+
+
+@dataclass
+class Account:
+    name: str
+    git_name: str
+    git_email: str
+    ssh_key: str
+    gh_host: str
+    gh_username: str
+
+
+def default_config_path() -> Path:
+    return Path.home() / ".config" / "gw" / "accounts.toml"
+
+
+def load_accounts(config_path: Path) -> list[Account]:
+    if not config_path.exists():
+        return []
+    try:
+        data = toml.loads(config_path.read_text())
+        return [Account(**entry) for entry in data.get("accounts", [])]
+    except (toml.TomlDecodeError, TypeError) as e:
+        raise ConfigError(f"{config_path} is not a valid gw config: {e}") from e
+
+
+def save_accounts(config_path: Path, accounts: list[Account]) -> None:
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    data = {"accounts": [asdict(a) for a in accounts]}
+    config_path.write_text(toml.dumps(data))
+
+
+def add_account(config_path: Path, account: Account, force: bool = False) -> None:
+    accounts = load_accounts(config_path)
+    existing_names = {a.name for a in accounts}
+
+    if account.name in existing_names:
+        if not force:
+            raise AccountExistsError(account.name)
+        accounts = [a for a in accounts if a.name != account.name]
+
+    accounts.append(account)
+    save_accounts(config_path, accounts)
+
+
+def remove_account(config_path: Path, name: str) -> None:
+    accounts = load_accounts(config_path)
+    remaining = [a for a in accounts if a.name != name]
+
+    if len(remaining) == len(accounts):
+        raise AccountNotFoundError(name)
+
+    save_accounts(config_path, remaining)
+
+
+def get_account(config_path: Path, name: str) -> Account:
+    for account in load_accounts(config_path):
+        if account.name == name:
+            return account
+    raise AccountNotFoundError(name)

gw/gh_ops.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+
+
+class GhOpsError(Exception):
+    pass
+
+
+def is_gh_installed() -> bool:
+    return shutil.which("gh") is not None
+
+
+def auth_login(host: str) -> None:
+    subprocess.run(["gh", "auth", "login", "--hostname", host])
+
+
+def auth_switch(host: str, username: str) -> None:
+    result = subprocess.run(
+        ["gh", "auth", "switch", "--hostname", host, "--user", username],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        raise GhOpsError(f"gh auth switch failed: {result.stderr.strip()}")
+
+
+def current_account(host: str) -> str | None:
+    result = subprocess.run(
+        ["gh", "api", "user", "--hostname", host, "-q", ".login"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        return None
+    login = result.stdout.strip()
+    return login or None
+
+
+def get_token(host: str, username: str) -> str | None:
+    result = subprocess.run(
+        ["gh", "auth", "token", "--hostname", host, "--user", username],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        return None
+    token = result.stdout.strip()
+    return token or None

gw/git_ops.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import shlex
+import subprocess
+from pathlib import Path
+from urllib.parse import urlsplit, urlunsplit
+
+
+class GitOpsError(Exception):
+    pass
+
+
+def is_inside_work_tree(cwd: Path | None = None) -> bool:
+    result = subprocess.run(
+        ["git", "rev-parse", "--is-inside-work-tree"],
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+    )
+    return result.returncode == 0 and result.stdout.strip() == "true"
+
+
+def set_local_config(key: str, value: str, cwd: Path | None = None) -> None:
+    result = subprocess.run(
+        ["git", "config", "--local", key, value],
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        raise GitOpsError(f"git config --local {key} failed: {result.stderr.strip()}")
+
+
+def get_local_config(key: str, cwd: Path | None = None) -> str | None:
+    result = subprocess.run(
+        ["git", "config", "--local", "--get", key],
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        return None
+    return result.stdout.strip()
+
+
+def get_remote_url(remote: str = "origin", cwd: Path | None = None) -> str | None:
+    return get_local_config(f"remote.{remote}.url", cwd=cwd)
+
+
+def _strip_url_credentials(url: str) -> str:
+    parts = urlsplit(url)
+    if not parts.scheme or "@" not in parts.netloc:
+        return url
+    host = parts.netloc.rsplit("@", 1)[-1]
+    return urlunsplit((parts.scheme, host, parts.path, parts.query, parts.fragment))
+
+
+def record_remote_account(remote_url: str, account_name: str) -> None:
+    remote_url = _strip_url_credentials(remote_url)
+
+    # Ensure the home directory exists, as git config needs it to write the global config.
+    home = Path.home()
+    try:
+        home.mkdir(parents=True, exist_ok=True)
+    except OSError as e:
+        raise GitOpsError(f"could not create home directory {home}: {e}") from e
+
+    key = f"gw-remote-map.{remote_url}.account"
+    result = subprocess.run(
+        ["git", "config", "--global", key, account_name],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        raise GitOpsError(f"git config --global {key} failed: {result.stderr.strip()}")
+
+
+def lookup_remote_account(remote_url: str) -> str | None:
+    remote_url = _strip_url_credentials(remote_url)
+
+    key = f"gw-remote-map.{remote_url}.account"
+    result = subprocess.run(
+        ["git", "config", "--global", "--get", key],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        return None
+    return result.stdout.strip()
+
+
+def set_local_credential_helper(gh_host: str, cwd: Path | None = None) -> None:
+    key = f"credential.https://{gh_host}.helper"
+
+    # Tolerate "no such key" (exit 5) — first-ever call in a repo has nothing to clear.
+    subprocess.run(
+        ["git", "config", "--local", "--unset-all", key],
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+    )
+
+    for value in ("", "!gw credential-helper"):
+        result = subprocess.run(
+            ["git", "config", "--local", "--add", key, value],
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            raise GitOpsError(f"git config --local --add {key} failed: {result.stderr.strip()}")
+
+
+def ssh_command_for_key(ssh_key_path: str) -> str:
+    expanded = Path(ssh_key_path).expanduser()
+    return f"ssh -i {shlex.quote(str(expanded))} -o IdentitiesOnly=yes"
+
+
+def is_linked_worktree(cwd: Path | None = None) -> bool:
+    git_dir = subprocess.run(
+        ["git", "rev-parse", "--git-dir"],
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+    )
+    common_dir = subprocess.run(
+        ["git", "rev-parse", "--git-common-dir"],
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+    )
+    if git_dir.returncode != 0 or common_dir.returncode != 0:
+        return False
+
+    base = cwd if cwd is not None else Path.cwd()
+    resolved_git_dir = (base / git_dir.stdout.strip()).resolve()
+    resolved_common_dir = (base / common_dir.stdout.strip()).resolve()
+    return resolved_git_dir != resolved_common_dir

gw/prompt_install.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+SCRIPT_CONTENT = (
+    "#!/bin/sh\n"
+    "acct=$(git config --local --get gw.account 2>/dev/null)\n"
+    "[ -n \"$acct\" ] && printf '[%s] ' \"$acct\"\n"
+    "exit 0\n"
+)
+
+MARKER_START = "# >>> gw prompt"
+MARKER_END = "# <<< gw prompt <<<"
+
+SUPPORTED_SHELLS = {"zsh", "bash"}
+
+_RC_FILENAMES = {
+    "zsh": ".zshrc",
+    "bash": ".bashrc",
+}
+
+
+class PromptInstallError(Exception):
+    pass
+
+
+@dataclass
+class InstallResult:
+    script_path: Path
+    rc_path: Path
+    newly_installed: bool
+
+
+def script_path() -> Path:
+    return Path.home() / ".local" / "bin" / "gw-prompt"
+
+
+def rc_file_path(shell: str) -> Path:
+    return Path.home() / _RC_FILENAMES[shell]
+
+
+def rc_block(shell: str, script_path: Path) -> str:
+    var_line = f'export GW_PROMPT="{script_path}"\n'
+    if shell == "zsh":
+        body = (
+            f"{var_line}"
+            "setopt PROMPT_SUBST\n"
+            "PROMPT='$($GW_PROMPT)'\"$PROMPT\"\n"
+        )
+    elif shell == "bash":
+        body = (
+            f"{var_line}"
+            "PS1='$($GW_PROMPT)'\"$PS1\"\n"
+        )
+    else:
+        raise PromptInstallError(f"unsupported shell: {shell!r}")
+    return (
+        f"{MARKER_START} (managed by `gw init {shell} --install`) >>>\n"
+        f"{body}"
+        f"{MARKER_END}\n"
+    )
+
+
+def is_already_installed(rc_path: Path) -> bool:
+    if not rc_path.exists():
+        return False
+    return MARKER_START in rc_path.read_text()
+
+
+def install(shell: str) -> InstallResult:
+    if shell not in SUPPORTED_SHELLS:
+        raise PromptInstallError(f"unsupported shell: {shell!r}")
+
+    path = script_path()
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(SCRIPT_CONTENT)
+        os.chmod(path, 0o755)
+    except OSError as e:
+        raise PromptInstallError(f"failed to write {path}: {e}") from e
+
+    rc_path = rc_file_path(shell)
+    try:
+        newly_installed = not is_already_installed(rc_path)
+        if newly_installed:
+            rc_path.parent.mkdir(parents=True, exist_ok=True)
+            prefix = "\n" if rc_path.exists() and rc_path.stat().st_size > 0 else ""
+            with rc_path.open("a") as f:
+                f.write(prefix + rc_block(shell, path))
+    except OSError as e:
+        raise PromptInstallError(f"failed to update {rc_path}: {e}") from e
+
+    return InstallResult(script_path=path, rc_path=rc_path, newly_installed=newly_installed)

gw/remote_check_install.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from gw import prompt_install
+
+CHECK_SCRIPT_CONTENT = (
+    "#!/bin/sh\n"
+    "url=$(git config --local --get remote.origin.url 2>/dev/null)\n"
+    "[ -z \"$url\" ] && exit 0\n"
+    "expected=$(git config --global --get \"gw-remote-map.$url.account\" 2>/dev/null)\n"
+    "[ -z \"$expected\" ] && exit 0\n"
+    "active=$(git config --local --get gw.account 2>/dev/null)\n"
+    "if [ \"$active\" != \"$expected\" ]; then\n"
+    "  printf 'gw: this repo usually uses account \"%s\" (currently: \"%s\"). Run `gw use %s` to switch.\\n' \"$expected\" \"${active:-none}\" \"$expected\" >&2\n"
+    "fi\n"
+    "exit 0\n"
+)
+
+CHECK_MARKER_START = "# >>> gw remote check"
+CHECK_MARKER_END = "# <<< gw remote check <<<"
+
+
+def check_script_path() -> Path:
+    return Path.home() / ".local" / "bin" / "gw-check"
+
+
+def chpwd_block(shell: str, check_script_path: Path) -> str:
+    var_line = f'export GW_CHECK="{check_script_path}"\n'
+    if shell == "zsh":
+        body = (
+            f"{var_line}"
+            'gw_chpwd_check() { "$GW_CHECK"; }\n'
+            "chpwd_functions+=(gw_chpwd_check)\n"
+        )
+    elif shell == "bash":
+        body = (
+            f"{var_line}"
+            'gw_last_pwd_for_check="$PWD"\n'
+            "gw_chpwd_check() {\n"
+            '  if [ "$PWD" != "$gw_last_pwd_for_check" ]; then\n'
+            '    gw_last_pwd_for_check="$PWD"\n'
+            '    "$GW_CHECK"\n'
+            "  fi\n"
+            "}\n"
+            'PROMPT_COMMAND="gw_chpwd_check${PROMPT_COMMAND:+; $PROMPT_COMMAND}"\n'
+        )
+    else:
+        raise prompt_install.PromptInstallError(f"unsupported shell: {shell!r}")
+    return (
+        f"{CHECK_MARKER_START} (managed by `gw init {shell} --install`) >>>\n"
+        f"{body}"
+        f"{CHECK_MARKER_END}\n"
+    )
+
+
+def is_check_already_installed(rc_path: Path) -> bool:
+    if not rc_path.exists():
+        return False
+    return CHECK_MARKER_START in rc_path.read_text()
+
+
+def install_check(shell: str) -> prompt_install.InstallResult:
+    if shell not in prompt_install.SUPPORTED_SHELLS:
+        raise prompt_install.PromptInstallError(f"unsupported shell: {shell!r}")
+
+    path = check_script_path()
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(CHECK_SCRIPT_CONTENT)
+        os.chmod(path, 0o755)
+    except OSError as e:
+        raise prompt_install.PromptInstallError(f"failed to write {path}: {e}") from e
+
+    rc_path = prompt_install.rc_file_path(shell)
+    try:
+        newly_installed = not is_check_already_installed(rc_path)
+        if newly_installed:
+            rc_path.parent.mkdir(parents=True, exist_ok=True)
+            prefix = "\n" if rc_path.exists() and rc_path.stat().st_size > 0 else ""
+            with rc_path.open("a") as f:
+                f.write(prefix + chpwd_block(shell, path))
+    except OSError as e:
+        raise prompt_install.PromptInstallError(f"failed to update {rc_path}: {e}") from e
+
+    return prompt_install.InstallResult(script_path=path, rc_path=rc_path, newly_installed=newly_installed)

gw/ssh_ops.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+
+class SshOpsError(Exception):
+    pass
+
+
+def key_exists(path: str) -> bool:
+    return Path(path).expanduser().exists()
+
+
+def public_key_path(private_key_path: str) -> str:
+    return f"{private_key_path}.pub"
+
+
+def read_public_key(path: str) -> str:
+    return Path(path).expanduser().read_text().strip()
+
+
+def generate_key(path: str, email: str) -> None:
+    expanded = Path(path).expanduser()
+    expanded.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+    result = subprocess.run(
+        [
+            "ssh-keygen",
+            "-t", "ed25519",
+            "-C", email,
+            "-f", str(expanded),
+            "-N", "",
+        ],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        raise SshOpsError(f"ssh-keygen failed: {result.stderr.strip()}")

gwitch-0.1.0.dist-info/METADATA

@@ -0,0 +1,143 @@
+Metadata-Version: 2.5
+Name: gwitch
+Version: 0.1.0
+Summary: Switch between git/GitHub accounts per repository.
+Project-URL: Homepage, https://github.com/isamrish/gwitch
+Project-URL: Repository, https://github.com/isamrish/gwitch
+Project-URL: Issues, https://github.com/isamrish/gwitch/issues
+Author-email: Amrish Kushwaha <askmaurya48@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Version Control :: Git
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Requires-Dist: toml>=0.10
+Requires-Dist: typer>=0.9
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# gw
+
+[![CI](https://github.com/isamrish/gwitch/actions/workflows/ci.yml/badge.svg)](https://github.com/isamrish/gwitch/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+Switch between multiple git/GitHub accounts, per repository, and see which
+account is active right in your shell prompt.
+
+## Install
+
+    pipx install gwitch
+
+Published on PyPI as `gwitch`; installs the `gw` command. Or, from a
+checkout of this repository:
+
+    pipx install .
+
+## Quick start
+
+    gw account add personal
+    gw account add work
+
+    cd ~/code/some-repo
+    gw use personal
+    gw status
+
+## Shell prompt
+
+    gw init zsh    # or bash / fish
+
+prints a small shell function, plus a one-line instruction for wiring it
+into your prompt — paste both into your shell config yourself. `gw` never
+edits your shell rc files automatically.
+
+    gw init zsh --install    # or bash
+
+`--install` does the wiring for you, for `zsh`/`bash` only (not `fish`
+yet): it writes a `gw-prompt` script to `~/.local/bin/gw-prompt` and a
+`gw-check` script to `~/.local/bin/gw-check` (the cd-triggered account-check
+described below), and appends two marked blocks to your rc file — one per
+script. It's idempotent — safe to re-run. Note for macOS bash users:
+`~/.bashrc` isn't read by login shells (Terminal and iTerm start bash as a
+login shell), so unless you've already wired `~/.bashrc` to be sourced from
+`~/.bash_profile`, you'll need to add that yourself for the installed
+integration to take effect.
+
+## What `gw use <account>` changes
+
+- `user.name` / `user.email` — local to the current repo only (`git config --local`)
+- `core.sshCommand` — forces the SSH key registered for that account
+- `gw.account` — a marker read by `gw status` and the shell prompt function
+- `gw-remote-map.<remote URL>.account` — records this repo's remote in **global** git config, for the cd-triggered mismatch check below
+
+`gw use` also records this repo's remote-to-account mapping in **global**
+git config (for the cd-triggered mismatch check, see below) — everything
+else stays local-only. None of this touches `~/.ssh/config` or ssh-agent.
+
+## Remote-account mismatch check
+
+With `gw init <shell> --install`, a `gw-check` script is wired to run every
+time your shell `cd`s into a different directory. If the repo you land in
+has an `origin` remote that `gw use <account>` has previously recorded, and
+the account currently active in that repo doesn't match, it prints a
+warning to stderr telling you which account to switch to. It never blocks
+or changes anything — it's purely informational.
+
+## Known limitations
+
+**`gh` (GitHub CLI) authentication is global, not per-repo.** GitHub CLI's
+authenticated account is global to your machine (`gh` keeps one active user
+per host), not per-repo — that's inherent to how `gh` itself works. `gw use
+<account>` will call `gh auth switch` for you, which changes `gh`'s active
+account machine-wide, even for other repos/terminal tabs, until you `gw use`
+a different account somewhere else. Your git identity and SSH key stay
+correctly isolated per-repo regardless.
+
+`gw status` shows both this repo's git identity and gh's currently active
+account as separate lines, so if they've drifted apart it's visible rather
+than silent.
+
+**Linked git worktrees share git identity.** `git config --local` in a
+linked worktree (created via `git worktree add`) resolves to the *same*
+shared config file as the main checkout — git only isolates local config
+per-worktree if the repo opts into `extensions.worktreeConfig`, which `gw`
+does not assume. That means `gw use <account>` run inside a linked worktree
+changes the identity for the main checkout and every sibling worktree of
+that repo too, not just the worktree you ran it in. `gw use` detects this
+and prints a warning when you run it inside a linked worktree, but it does
+not block the switch or set up per-worktree config automatically.
+
+**The remote-account check is last-write-wins, URL-exact, and cd-triggered
+only.** The `gw-remote-map` registry has no per-clone tracking: running `gw
+use <account>` anywhere for a given remote overwrites what "the right
+account" means for every other clone of that remote — this is intentional,
+not a bug. It also matches on the exact remote URL string, so an SSH clone
+and an HTTPS clone of the same repo are treated as two unrelated remotes.
+And because the check only runs on `cd`, a shell already sitting in a
+mismatched repo when it starts won't warn until you `cd` away and back.
+
+## Commands
+
+- `gw account add <name>` — register an account (prompts for git name/email,
+  GitHub username; can generate a new SSH key for you)
+- `gw account list` — list registered accounts
+- `gw account remove <name>` — remove a registered account
+- `gw use <name>` — activate an account for the current repo
+- `gw status` / `gw whoami` — show the active account for the current repo
+- `gw init <shell>` — print the shell prompt snippet for `zsh`, `bash`, or
+  `fish`; add `--install` (`zsh`/`bash` only) to write and wire it up automatically
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for dev setup and how to run the
+tests. Please follow the [Code of Conduct](CODE_OF_CONDUCT.md). For security
+issues, see [SECURITY.md](SECURITY.md) instead of opening a public issue.
+
+## License
+
+[MIT](LICENSE)

gwitch-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+gw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gw/cli.py,sha256=LC79V39Y9D8yyaMbcSOf97qNJzvsL-YLJXkxR4qYq5U,815
+gw/config.py,sha256=G-qvtgpWdJFvnykarB-r5aIW8AHEAnNPHfOHvQCDAaE,2006
+gw/gh_ops.py,sha256=IXq7mXLqN7flz5fR75B4KilP1xL_PUgp8BGxwzfi6Fg,1232
+gw/git_ops.py,sha256=3tSc5LBBem1ECT_SdTlIH6iS4uPZG-0eGNXzbvjLYUc,4216
+gw/prompt_install.py,sha256=VsdVeU2oOAR7KKTxrshapyb6YX6tSbvVtEN34YtOd5I,2494
+gw/remote_check_install.py,sha256=IL60uM3RNFeqQvOJA8P1oI8SC5W4b9OaBRQdmllIufU,3102
+gw/ssh_ops.py,sha256=eHm5IlLwbvZmorNDYkOl6yWN9rDNZGy98qR8NVv8MCM,887
+gw/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gw/commands/account.py,sha256=VOj9sD1G5MpStdNJYrlgk8EDVHx2CqGxQCiVEmW01J8,3994
+gw/commands/credential_helper.py,sha256=yf5glZ2aTTEKjUYH094qGxq9baGUOI_NrlbhC2sOSLM,1155
+gw/commands/init_cmd.py,sha256=wwtDoog6SixcjkGG0Yx5bpyewXkPls2JZnwJwHlZ2qE,3584
+gw/commands/status.py,sha256=QKh5aD1AJDu51twZwPitw7uoLvRu6JN3xxgkbNpe_L8,2010
+gw/commands/use.py,sha256=uezNUwypc3lmQK4107Rr5lLS9j0vThxYJVCiFh7gb70,3395
+gwitch-0.1.0.dist-info/METADATA,sha256=_QzmNxr68hUJyrVYrlgvGS6TYSu5EC2rIqSeK-zsTWI,6256
+gwitch-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+gwitch-0.1.0.dist-info/entry_points.txt,sha256=YqwMeBups4XCt88wIKG4qxYGsOEOFI-_YNiEoNDJaow,35
+gwitch-0.1.0.dist-info/licenses/LICENSE,sha256=4UBvHnhpvGU9C50HJ-SNBOxNK_JiVhaM_5oXofA_Y-Y,1072
+gwitch-0.1.0.dist-info/RECORD,,

gwitch-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

gwitch-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gw = gw.cli:main

gwitch-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Amrish Kushwaha
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.