gitacc-switcher 1.2.1__tar.gz → 1.4.0__tar.gz

{gitacc_switcher-1.2.1/gitacc_switcher.egg-info → gitacc_switcher-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitacc-switcher
-Version: 1.2.1
+Version: 1.4.0
 Summary: Git Account Switcher - Manage multiple Git SSH accounts easily
 Home-page: https://github.com/ktechhub/gitacc_switcher
 Author: ktechhub
@@ -49,6 +49,7 @@ A Python CLI tool to easily switch between multiple Git SSH accounts. Manage mul
 - Opt-in SSH commit signing per account
 - Colored terminal output with active account indicator
 - Pre-commit hook to prevent commits with the wrong account
+- Opt-in directory-based auto-switching (`gitacc rule`) with a bash/zsh shell hook
 - Shell autocomplete for bash and zsh
 - Cross-platform support (Linux / macOS)
 
@@ -184,6 +185,40 @@ Kill the SSH agent and unset the global Git user config.
 gitacc logout
 ```
 
+### `gitacc rule add <account> [directory]` / `gitacc rule remove [directory]` / `gitacc rule list`
+
+Opt-in, direnv-style directory-based auto-switching: bind an account to a directory (and
+everything beneath it) so the right identity is picked automatically as you move around, instead
+of running `gitacc switch` by hand. `directory` defaults to the current directory. The most
+specific matching directory wins, so a rule on a subdirectory overrides one on its parent.
+
+```bash
+gitacc rule add work ~/projects/work      # anything under ~/projects/work uses "work"
+gitacc rule add personal ~/projects/side  # anything under ~/projects/side uses "personal"
+gitacc rule list
+gitacc rule remove ~/projects/side
+```
+
+Rules by themselves don't do anything — nothing triggers on `cd` until you install the shell hook
+below.
+
+### `gitacc rule hook <bash|zsh>`
+
+Print a shell snippet that calls `gitacc rule check` so rules apply automatically. Add it to your
+shell profile and restart your shell (or `source` it):
+
+```bash
+# bash
+gitacc rule hook bash >> ~/.bashrc
+
+# zsh
+gitacc rule hook zsh >> ~/.zshrc
+```
+
+The hook is silent unless it actually needs to switch accounts: no matching rule, an SSH agent
+that isn't running, or an identity that's already correct all do nothing. This is entirely
+opt-in — `gitacc rule add` alone never touches your shell config.
+
 ### `gitacc autocomplete install`
 
 Install tab-completion for your shell (bash or zsh). After running, restart your shell or `source` your profile.
@@ -212,6 +247,7 @@ gitacc --version
 | Path | Purpose |
 |------|---------|
 | `~/.gitacc` | Stores all account entries (INI format) |
+| `~/.gitaccrules` | Directory → account rules for `gitacc rule` (opt-in auto-switch) |
 | `~/.ssh/id_<type>_<account>` | Private SSH key per account |
 | `~/.ssh/id_<type>_<account>.pub` | Public SSH key per account |
 
@@ -226,6 +262,13 @@ gitacc --version
     sign = false
 ```
 
+`~/.gitaccrules` format (one rule per line, most-specific directory wins):
+
+```
+/home/jane/projects/work = work
+/home/jane/projects/work/client-a = client-a
+```
+
 ## Requirements
 
 - Python 3.8+

{gitacc_switcher-1.2.1 → gitacc_switcher-1.4.0}/README.md

@@ -16,6 +16,7 @@ A Python CLI tool to easily switch between multiple Git SSH accounts. Manage mul
 - Opt-in SSH commit signing per account
 - Colored terminal output with active account indicator
 - Pre-commit hook to prevent commits with the wrong account
+- Opt-in directory-based auto-switching (`gitacc rule`) with a bash/zsh shell hook
 - Shell autocomplete for bash and zsh
 - Cross-platform support (Linux / macOS)
 
@@ -151,6 +152,40 @@ Kill the SSH agent and unset the global Git user config.
 gitacc logout
 ```
 
+### `gitacc rule add <account> [directory]` / `gitacc rule remove [directory]` / `gitacc rule list`
+
+Opt-in, direnv-style directory-based auto-switching: bind an account to a directory (and
+everything beneath it) so the right identity is picked automatically as you move around, instead
+of running `gitacc switch` by hand. `directory` defaults to the current directory. The most
+specific matching directory wins, so a rule on a subdirectory overrides one on its parent.
+
+```bash
+gitacc rule add work ~/projects/work      # anything under ~/projects/work uses "work"
+gitacc rule add personal ~/projects/side  # anything under ~/projects/side uses "personal"
+gitacc rule list
+gitacc rule remove ~/projects/side
+```
+
+Rules by themselves don't do anything — nothing triggers on `cd` until you install the shell hook
+below.
+
+### `gitacc rule hook <bash|zsh>`
+
+Print a shell snippet that calls `gitacc rule check` so rules apply automatically. Add it to your
+shell profile and restart your shell (or `source` it):
+
+```bash
+# bash
+gitacc rule hook bash >> ~/.bashrc
+
+# zsh
+gitacc rule hook zsh >> ~/.zshrc
+```
+
+The hook is silent unless it actually needs to switch accounts: no matching rule, an SSH agent
+that isn't running, or an identity that's already correct all do nothing. This is entirely
+opt-in — `gitacc rule add` alone never touches your shell config.
+
 ### `gitacc autocomplete install`
 
 Install tab-completion for your shell (bash or zsh). After running, restart your shell or `source` your profile.
@@ -179,6 +214,7 @@ gitacc --version
 | Path | Purpose |
 |------|---------|
 | `~/.gitacc` | Stores all account entries (INI format) |
+| `~/.gitaccrules` | Directory → account rules for `gitacc rule` (opt-in auto-switch) |
 | `~/.ssh/id_<type>_<account>` | Private SSH key per account |
 | `~/.ssh/id_<type>_<account>.pub` | Public SSH key per account |
 
@@ -193,6 +229,13 @@ gitacc --version
     sign = false
 ```
 
+`~/.gitaccrules` format (one rule per line, most-specific directory wins):
+
+```
+/home/jane/projects/work = work
+/home/jane/projects/work/client-a = client-a
+```
+
 ## Requirements
 
 - Python 3.8+

{gitacc_switcher-1.2.1 → gitacc_switcher-1.4.0}/gitacc_switcher/__init__.py

@@ -1,4 +1,4 @@
 """Git Account Switcher - Manage multiple Git SSH accounts easily."""
 
-__version__ = "1.2.1"
+__version__ = "1.4.0"
 __author__ = "ktechhub"

{gitacc_switcher-1.2.1 → gitacc_switcher-1.4.0}/gitacc_switcher/account_manager.py

@@ -7,6 +7,7 @@ from typing import Optional, Dict, List
 from .config_manager import ConfigManager
 from .ssh_manager import SSHManager
 from .hook_manager import HookManager
+from .rules_manager import RulesManager
 from .utils import echo_color, ask_yes_no, validate_ssh_key_type
 
 
@@ -17,6 +18,7 @@ class AccountManager:
         self.config_manager = ConfigManager()
         self.ssh_manager = SSHManager()
         self.hook_manager = HookManager()
+        self.rules_manager = RulesManager()
 
     def add_account(self, key_type: str = "rsa", sign: bool = False) -> bool:
         """Add a new Git account.
@@ -382,6 +384,67 @@ class AccountManager:
 
         return True
 
+    def get_status(self, repo_path: Optional[Path] = None) -> Dict[str, object]:
+        """Report the currently active Git identity and SSH agent key, and
+        which registered account (if any) they match.
+
+        Read-only: makes no changes to Git config, the SSH agent, or any
+        managed files.
+
+        Args:
+            repo_path: Path to repository (default: current directory). Used
+                to resolve local Git config when run inside a repo.
+
+        Returns:
+            Dictionary with the current name/email, the matched account name
+            (or None), whether the SSH agent is running, and which account
+            (if any) the currently loaded agent key belongs to.
+        """
+        if self.config_manager.is_git_repo(repo_path):
+            current_config = self.config_manager.get_current_git_config_local(repo_path)
+        else:
+            current_config = self.config_manager.get_current_git_config()
+
+        current_name = current_config.get("name")
+        current_email = current_config.get("email")
+
+        accounts = self.config_manager.read_accounts()
+
+        matched_account = None
+        for account_name, account_info in accounts.items():
+            if (
+                current_name
+                and current_email
+                and account_info.get("name") == current_name
+                and account_info.get("email") == current_email
+            ):
+                matched_account = account_name
+                break
+
+        agent_running = self.ssh_manager.is_ssh_agent_running()
+        agent_fingerprints = (
+            self.ssh_manager.get_agent_fingerprints() if agent_running else []
+        )
+
+        matched_key_account = None
+        if agent_fingerprints:
+            for account_name, account_info in accounts.items():
+                public_key = account_info.get("public_key")
+                if not public_key:
+                    continue
+                fingerprint = self.ssh_manager.get_key_fingerprint(public_key)
+                if fingerprint and fingerprint in agent_fingerprints:
+                    matched_key_account = account_name
+                    break
+
+        return {
+            "name": current_name,
+            "email": current_email,
+            "matched_account": matched_account,
+            "agent_running": agent_running,
+            "matched_key_account": matched_key_account,
+        }
+
     def init_repo(self, account_name: str, repo_path: Optional[Path] = None) -> bool:
         """Initialize repository with expected account and install pre-commit hook.
 

{gitacc_switcher-1.2.1 → gitacc_switcher-1.4.0}/gitacc_switcher/cli.py

@@ -2,6 +2,7 @@
 
 import argparse
 import sys
+from pathlib import Path
 from typing import Optional
 
 try:
@@ -12,6 +13,7 @@ except ImportError:
 from . import __version__
 from .account_manager import AccountManager
 from .completion import get_account_names
+from .shell_hook import get_hook_script, get_supported_shells
 from .utils import echo_color, get_ssh_key_types
 
 
@@ -45,10 +47,12 @@ class CLI:
         self._add_switch_command(subparsers)
         self._add_list_command(subparsers)
         self._add_logout_command(subparsers)
+        self._add_status_command(subparsers)
         self._add_init_command(subparsers)
         self._add_verify_command(subparsers)
         self._add_update_command(subparsers)
         self._add_autocomplete_command(subparsers)
+        self._add_rule_command(subparsers)
 
         # Include account names in top-level completion so `gitacc <TAB>` works for
         # the `gitacc <account>` shorthand, not just for subcommand names.
@@ -74,9 +78,12 @@ Examples:
   gitacc remove myaccount       Remove an account
   gitacc list                   List all registered accounts
   gitacc logout                 Logout current account
+  gitacc status                 Show the currently active account
   gitacc init myaccount         Initialize repo with account validation
   gitacc verify                 Verify current account matches repo
   gitacc update myaccount       Update Git name for an account
+  gitacc rule add work ~/work   Auto-switch to "work" inside that directory
+  gitacc rule hook bash         Print the shell hook (add to ~/.bashrc)
         """
 
     def _add_add_command(self, subparsers: argparse._SubParsersAction) -> None:
@@ -158,6 +165,16 @@ Examples:
         )
         parser.set_defaults(func=self._handle_logout)
 
+    def _add_status_command(self, subparsers: argparse._SubParsersAction) -> None:
+        """Add the 'status' command parser."""
+        parser = subparsers.add_parser(
+            "status",
+            help="Show the currently active account",
+            description="Show the current Git identity and SSH agent key, "
+            "and which managed account (if any) matches",
+        )
+        parser.set_defaults(func=self._handle_status)
+
     def _add_init_command(self, subparsers: argparse._SubParsersAction) -> None:
         """Add the 'init' command parser."""
         parser = subparsers.add_parser(
@@ -242,6 +259,80 @@ Examples:
         )
         install_parser.set_defaults(func=self._handle_autocomplete_install)
 
+    def _add_rule_command(self, subparsers: argparse._SubParsersAction) -> None:
+        """Add the 'rule' command parser for directory-based auto-switching."""
+        parser = subparsers.add_parser(
+            "rule",
+            help="Manage directory-based account auto-switch rules",
+            description="Add, remove, and list rules that auto-switch accounts by directory",
+        )
+        rule_subparsers = parser.add_subparsers(
+            dest="rule_command",
+            help="Rule commands",
+        )
+
+        add_parser = rule_subparsers.add_parser(
+            "add",
+            help="Add or update a directory rule",
+            description="Auto-switch to an account whenever inside the given "
+            "directory (or a subdirectory of it)",
+        )
+        account_arg = add_parser.add_argument(
+            "account_name",
+            help="Account to switch to",
+        )
+        add_parser.add_argument(
+            "directory",
+            nargs="?",
+            default=None,
+            help="Directory the rule applies to (default: current directory)",
+        )
+        if argcomplete:
+            account_arg.completer = lambda **kwargs: get_account_names()
+        add_parser.set_defaults(func=self._handle_rule_add)
+
+        remove_parser = rule_subparsers.add_parser(
+            "remove",
+            help="Remove a directory rule",
+        )
+        remove_parser.add_argument(
+            "directory",
+            nargs="?",
+            default=None,
+            help="Directory whose rule should be removed (default: current directory)",
+        )
+        remove_parser.set_defaults(func=self._handle_rule_remove)
+
+        list_parser = rule_subparsers.add_parser(
+            "list",
+            help="List all directory rules",
+        )
+        list_parser.set_defaults(func=self._handle_rule_list)
+
+        hook_parser = rule_subparsers.add_parser(
+            "hook",
+            help="Print a shell hook that auto-switches on directory change",
+            description="Print a snippet for your shell profile that calls "
+            "'gitacc rule check' so rules apply automatically as you move "
+            "between directories",
+        )
+        hook_parser.add_argument(
+            "shell",
+            choices=get_supported_shells(),
+            help="Shell to generate the hook for",
+        )
+        hook_parser.set_defaults(func=self._handle_rule_hook)
+
+        check_parser = rule_subparsers.add_parser(
+            "check",
+            help="Match the current directory against rules (used by the shell hook)",
+            description="Intended to be called by the shell hook on every "
+            "prompt render, not run directly; silently does nothing unless "
+            "the current directory matches a rule for a different account "
+            "than the one currently active",
+        )
+        check_parser.set_defaults(func=self._handle_rule_check)
+
     def _handle_autocomplete_install(self, args: argparse.Namespace) -> int:
         """Handle the 'autocomplete install' command."""
         if not argcomplete:
@@ -396,6 +487,35 @@ Examples:
         success = self.account_manager.logout()
         return 0 if success else 1
 
+    def _handle_status(self, args: argparse.Namespace) -> int:
+        """Handle the 'status' command."""
+        status = self.account_manager.get_status()
+        name = status.get("name")
+        email = status.get("email")
+
+        echo_color("g", "Current Git identity:")
+        echo_color("g", f"  Name:  {name or '(not set)'}")
+        echo_color("g", f"  Email: {email or '(not set)'}")
+
+        matched_account = status.get("matched_account")
+        if matched_account:
+            echo_color("g", f'Matched account: "{matched_account}"')
+        else:
+            echo_color("y", "No managed account matches the current Git identity.")
+
+        if status.get("agent_running"):
+            matched_key_account = status.get("matched_key_account")
+            if matched_key_account:
+                echo_color(
+                    "g", f'SSH agent key matches account: "{matched_key_account}"'
+                )
+            else:
+                echo_color("y", "SSH agent key does not match any managed account.")
+        else:
+            echo_color("y", "SSH agent is not running.")
+
+        return 0
+
     def _handle_init(self, args: argparse.Namespace) -> int:
         """Handle the 'init' command."""
         success = self.account_manager.init_repo(args.account_name)
@@ -416,6 +536,80 @@ Examples:
         )
         return 0 if success else 1
 
+    def _handle_rule_add(self, args: argparse.Namespace) -> int:
+        """Handle the 'rule add' command."""
+        if not self.account_manager.account_exists(args.account_name):
+            echo_color("r", f'Account "{args.account_name}" not found!')
+            return 1
+
+        directory = Path(args.directory) if args.directory else Path.cwd()
+        success = self.account_manager.rules_manager.add_rule(
+            directory, args.account_name
+        )
+        if success:
+            resolved = Path(directory).expanduser().resolve()
+            echo_color("g", f'Rule added: "{resolved}" → "{args.account_name}"')
+        else:
+            echo_color("r", "Failed to add rule!")
+        return 0 if success else 1
+
+    def _handle_rule_remove(self, args: argparse.Namespace) -> int:
+        """Handle the 'rule remove' command."""
+        directory = Path(args.directory) if args.directory else Path.cwd()
+        success = self.account_manager.rules_manager.remove_rule(directory)
+        resolved = Path(directory).expanduser().resolve()
+        if success:
+            echo_color("g", f'Rule removed for "{resolved}"')
+        else:
+            echo_color("y", f'No rule was set for "{resolved}"')
+        return 0 if success else 1
+
+    def _handle_rule_list(self, args: argparse.Namespace) -> int:
+        """Handle the 'rule list' command."""
+        rules = self.account_manager.rules_manager.list_rules()
+        if not rules:
+            echo_color("y", "No directory rules registered yet.")
+            return 0
+
+        echo_color("g", "Directory auto-switch rules:")
+        for directory, account_name in rules.items():
+            print(f"  {directory} → {account_name}")
+        return 0
+
+    def _handle_rule_hook(self, args: argparse.Namespace) -> int:
+        """Handle the 'rule hook' command."""
+        script = get_hook_script(args.shell)
+        if not script:
+            echo_color("r", f'Unsupported shell: "{args.shell}"')
+            return 1
+        print(script)
+        return 0
+
+    def _handle_rule_check(self, args: argparse.Namespace) -> int:
+        """Handle the 'rule check' command.
+
+        Called by the installed shell hook on every prompt render, so it
+        must stay quiet unless there is actually something to do: no match,
+        an already-correct identity, and a down SSH agent (which
+        `switch_account` would otherwise report loudly on every prompt) are
+        all silent no-ops.
+        """
+        account_name = self.account_manager.rules_manager.find_matching_account(
+            Path.cwd()
+        )
+        if not account_name or not self.account_manager.account_exists(account_name):
+            return 0
+
+        status = self.account_manager.get_status()
+        if status.get("matched_account") == account_name:
+            return 0
+
+        if not self.account_manager.ssh_manager.is_ssh_agent_running():
+            return 0
+
+        success = self.account_manager.switch_account(account_name)
+        return 0 if success else 1
+
     def _handle_account_name_shortcut(self, account_name: str) -> int:
         """Handle account name as shortcut for switch command."""
         success = self.account_manager.switch_account(account_name)

gitacc_switcher-1.4.0/gitacc_switcher/rules_manager.py

@@ -0,0 +1,118 @@
+"""Directory-based auto-switch rule storage and lookup.
+
+Rules map a directory (and everything beneath it) to the account that should
+become active whenever the shell's current working directory is there. This
+is the pure-Python half of the opt-in auto-switch feature; the actual
+"notice I changed directories" trigger comes from a shell hook (see
+`shell_hook.py`) that calls `gitacc rule check` on every prompt render.
+"""
+
+import re
+from pathlib import Path
+from typing import Dict, Optional
+
+
+class RulesManager:
+    """Manages directory-to-account auto-switch rules."""
+
+    def __init__(self, rules_file: Optional[Path] = None):
+        self.rules_file = rules_file or (Path.home() / ".gitaccrules")
+
+    def _normalize_path(self, directory: Path) -> str:
+        """Resolve a directory to its canonical absolute form."""
+        return str(Path(directory).expanduser().resolve())
+
+    def list_rules(self) -> Dict[str, str]:
+        """Read all rules from the rules file.
+
+        Returns:
+            Dictionary mapping normalized directory path to account name, in
+            file order. Blank lines and lines starting with '#' are ignored.
+        """
+        rules: Dict[str, str] = {}
+        if not self.rules_file.exists():
+            return rules
+
+        with open(self.rules_file, "r") as f:
+            for raw_line in f:
+                line = raw_line.strip()
+                if not line or line.startswith("#"):
+                    continue
+                match = re.match(r"^(.+?)\s*=\s*(.+)$", line)
+                if not match:
+                    continue
+                directory = match.group(1).strip()
+                account_name = match.group(2).strip()
+                if directory and account_name:
+                    rules[directory] = account_name
+
+        return rules
+
+    def _write_rules(self, rules: Dict[str, str]) -> None:
+        with open(self.rules_file, "w") as f:
+            for directory, account_name in rules.items():
+                f.write(f"{directory} = {account_name}\n")
+
+    def add_rule(self, directory: Path, account_name: str) -> bool:
+        """Add or update the rule for a directory.
+
+        Args:
+            directory: Directory the rule applies to (and its subdirectories)
+            account_name: Account to switch to while inside that directory
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            normalized = self._normalize_path(directory)
+            rules = self.list_rules()
+            rules[normalized] = account_name
+            self._write_rules(rules)
+            return True
+        except OSError:
+            return False
+
+    def remove_rule(self, directory: Path) -> bool:
+        """Remove the rule for a directory, if one exists.
+
+        Args:
+            directory: Directory whose rule should be removed
+
+        Returns:
+            True if a rule was removed, False if none existed or on error
+        """
+        try:
+            normalized = self._normalize_path(directory)
+            rules = self.list_rules()
+            if normalized not in rules:
+                return False
+            del rules[normalized]
+            self._write_rules(rules)
+            return True
+        except OSError:
+            return False
+
+    def find_matching_account(self, cwd: Path) -> Optional[str]:
+        """Find the account whose rule most specifically matches a directory.
+
+        Walks from the given directory up through its parents, direnv-style,
+        and returns the account for the first (deepest, most specific) rule
+        directory that is the given directory or an ancestor of it.
+
+        Args:
+            cwd: Directory to match against registered rules
+
+        Returns:
+            Matching account name, or None if no rule applies
+        """
+        rules = self.list_rules()
+        if not rules:
+            return None
+
+        current = Path(cwd).expanduser().resolve()
+        for directory in [current, *current.parents]:
+            account_name = rules.get(str(directory))
+            if account_name:
+                return account_name
+
+        return None

gitacc_switcher-1.4.0/gitacc_switcher/shell_hook.py

@@ -0,0 +1,51 @@
+"""Shell hook snippets for directory-based auto-switching.
+
+These are opt-in: nothing in gitacc installs them automatically. A user adds
+the output of `gitacc rule hook <shell>` to their shell profile, which then
+calls `gitacc rule check` whenever the prompt is rendered (bash) or the
+working directory changes (zsh), so the active account follows whatever
+rules were registered with `gitacc rule add`.
+"""
+
+from typing import Optional
+
+_BASH_HOOK = """\
+_gitacc_hook() {
+  local previous_exit_status=$?
+  command gitacc rule check
+  return $previous_exit_status
+}
+if [[ ";${PROMPT_COMMAND:-};" != *";_gitacc_hook;"* ]]; then
+  PROMPT_COMMAND="_gitacc_hook${PROMPT_COMMAND:+;$PROMPT_COMMAND}"
+fi"""
+
+_ZSH_HOOK = """\
+_gitacc_hook() {
+  command gitacc rule check
+}
+if [[ -z "${chpwd_functions[(r)_gitacc_hook]}" ]]; then
+  chpwd_functions+=(_gitacc_hook)
+fi
+_gitacc_hook"""
+
+_HOOKS = {
+    "bash": _BASH_HOOK,
+    "zsh": _ZSH_HOOK,
+}
+
+
+def get_hook_script(shell: str) -> Optional[str]:
+    """Get the shell hook snippet for a given shell.
+
+    Args:
+        shell: Shell name ("bash" or "zsh")
+
+    Returns:
+        Hook script text, or None if the shell isn't supported
+    """
+    return _HOOKS.get(shell.lower())
+
+
+def get_supported_shells() -> list:
+    """Get the list of shells a hook script can be generated for."""
+    return list(_HOOKS.keys())