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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitacc-switcher
-Version: 1.3.0
+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.3.0 → 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.3.0 → gitacc_switcher-1.4.0}/gitacc_switcher/__init__.py

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

{gitacc_switcher-1.3.0 → 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.

{gitacc_switcher-1.3.0 → 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
 
 
@@ -50,6 +52,7 @@ class CLI:
         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.
@@ -79,6 +82,8 @@ Examples:
   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:
@@ -254,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:
@@ -457,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())

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitacc-switcher
-Version: 1.3.0
+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.3.0 → gitacc_switcher-1.4.0}/gitacc_switcher.egg-info/SOURCES.txt

@@ -10,6 +10,8 @@ gitacc_switcher/cli.py
 gitacc_switcher/completion.py
 gitacc_switcher/config_manager.py
 gitacc_switcher/hook_manager.py
+gitacc_switcher/rules_manager.py
+gitacc_switcher/shell_hook.py
 gitacc_switcher/ssh_manager.py
 gitacc_switcher/utils.py
 gitacc_switcher.egg-info/PKG-INFO
@@ -24,5 +26,7 @@ tests/test_cli.py
 tests/test_completion.py
 tests/test_config_manager.py
 tests/test_hook_manager.py
+tests/test_rules_manager.py
+tests/test_shell_hook.py
 tests/test_ssh_manager.py
 tests/test_utils.py

{gitacc_switcher-1.3.0 → gitacc_switcher-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gitacc-switcher"
-version = "1.3.0"
+version = "1.4.0"
 description = "Git Account Switcher - Manage multiple Git SSH accounts easily"
 readme = "README.md"
 requires-python = ">=3.7"

{gitacc_switcher-1.3.0 → gitacc_switcher-1.4.0}/setup.py

@@ -9,7 +9,7 @@ long_description = readme_file.read_text() if readme_file.exists() else ""
 
 setup(
     name="gitacc-switcher",
-    version="1.3.0",
+    version="1.4.0",
     description="Git Account Switcher - Manage multiple Git SSH accounts easily",
     long_description=long_description,
     long_description_content_type="text/markdown",

{gitacc_switcher-1.3.0 → gitacc_switcher-1.4.0}/tests/test_cli.py

@@ -354,3 +354,143 @@ class TestRun:
         with patch.object(sys, "argv", ["gitacc", "status"]):
             result = cli.run()
         assert result == 0
+
+
+# ---------------------------------------------------------------------------
+# `rule` command parsing
+# ---------------------------------------------------------------------------
+
+
+class TestRuleParserCommands:
+    def test_rule_add_parses_account_and_directory(self, cli):
+        args = cli.parser.parse_args(["rule", "add", "work", "/tmp/work"])
+        assert args.command == "rule"
+        assert args.rule_command == "add"
+        assert args.account_name == "work"
+        assert args.directory == "/tmp/work"
+
+    def test_rule_add_directory_defaults_to_none(self, cli):
+        args = cli.parser.parse_args(["rule", "add", "work"])
+        assert args.directory is None
+
+    def test_rule_remove_parses_directory(self, cli):
+        args = cli.parser.parse_args(["rule", "remove", "/tmp/work"])
+        assert args.directory == "/tmp/work"
+
+    def test_rule_remove_directory_defaults_to_none(self, cli):
+        args = cli.parser.parse_args(["rule", "remove"])
+        assert args.directory is None
+
+    def test_rule_list_command(self, cli):
+        args = cli.parser.parse_args(["rule", "list"])
+        assert args.rule_command == "list"
+
+    def test_rule_hook_parses_shell(self, cli):
+        args = cli.parser.parse_args(["rule", "hook", "zsh"])
+        assert args.shell == "zsh"
+
+    def test_rule_hook_rejects_unsupported_shell(self, cli):
+        with pytest.raises(SystemExit):
+            cli.parser.parse_args(["rule", "hook", "fish"])
+
+    def test_rule_check_command(self, cli):
+        args = cli.parser.parse_args(["rule", "check"])
+        assert args.rule_command == "check"
+
+
+# ---------------------------------------------------------------------------
+# `rule` command handlers
+# ---------------------------------------------------------------------------
+
+
+class TestRuleHandlers:
+    def test_handle_rule_add_success(self, cli):
+        cli.account_manager.account_exists.return_value = True
+        cli.account_manager.rules_manager.add_rule.return_value = True
+        args = argparse.Namespace(account_name="work", directory="/tmp/work")
+        assert cli._handle_rule_add(args) == 0
+
+    def test_handle_rule_add_unknown_account(self, cli):
+        cli.account_manager.account_exists.return_value = False
+        args = argparse.Namespace(account_name="ghost", directory=None)
+        assert cli._handle_rule_add(args) == 1
+        cli.account_manager.rules_manager.add_rule.assert_not_called()
+
+    def test_handle_rule_add_failure(self, cli):
+        cli.account_manager.account_exists.return_value = True
+        cli.account_manager.rules_manager.add_rule.return_value = False
+        args = argparse.Namespace(account_name="work", directory="/tmp/work")
+        assert cli._handle_rule_add(args) == 1
+
+    def test_handle_rule_remove_success(self, cli):
+        cli.account_manager.rules_manager.remove_rule.return_value = True
+        args = argparse.Namespace(directory="/tmp/work")
+        assert cli._handle_rule_remove(args) == 0
+
+    def test_handle_rule_remove_no_rule(self, cli):
+        cli.account_manager.rules_manager.remove_rule.return_value = False
+        args = argparse.Namespace(directory="/tmp/work")
+        assert cli._handle_rule_remove(args) == 1
+
+    def test_handle_rule_list_empty(self, cli):
+        cli.account_manager.rules_manager.list_rules.return_value = {}
+        assert cli._handle_rule_list(argparse.Namespace()) == 0
+
+    def test_handle_rule_list_with_rules(self, cli, capsys):
+        cli.account_manager.rules_manager.list_rules.return_value = {
+            "/home/jane/work": "work"
+        }
+        result = cli._handle_rule_list(argparse.Namespace())
+        assert result == 0
+        assert "/home/jane/work" in capsys.readouterr().out
+
+    def test_handle_rule_hook_prints_script(self, cli, capsys):
+        result = cli._handle_rule_hook(argparse.Namespace(shell="bash"))
+        assert result == 0
+        assert "gitacc rule check" in capsys.readouterr().out
+
+    def test_handle_rule_hook_unsupported_shell(self, cli):
+        assert cli._handle_rule_hook(argparse.Namespace(shell="fish")) == 1
+
+    def test_handle_rule_check_no_match_is_noop(self, cli):
+        cli.account_manager.rules_manager.find_matching_account.return_value = None
+        assert cli._handle_rule_check(argparse.Namespace()) == 0
+        cli.account_manager.switch_account.assert_not_called()
+
+    def test_handle_rule_check_unknown_account_is_noop(self, cli):
+        cli.account_manager.rules_manager.find_matching_account.return_value = "ghost"
+        cli.account_manager.account_exists.return_value = False
+        assert cli._handle_rule_check(argparse.Namespace()) == 0
+        cli.account_manager.switch_account.assert_not_called()
+
+    def test_handle_rule_check_already_matching_is_noop(self, cli):
+        cli.account_manager.rules_manager.find_matching_account.return_value = "work"
+        cli.account_manager.account_exists.return_value = True
+        cli.account_manager.get_status.return_value = {"matched_account": "work"}
+        assert cli._handle_rule_check(argparse.Namespace()) == 0
+        cli.account_manager.switch_account.assert_not_called()
+
+    def test_handle_rule_check_agent_down_is_noop(self, cli):
+        cli.account_manager.rules_manager.find_matching_account.return_value = "work"
+        cli.account_manager.account_exists.return_value = True
+        cli.account_manager.get_status.return_value = {"matched_account": "personal"}
+        cli.account_manager.ssh_manager.is_ssh_agent_running.return_value = False
+        assert cli._handle_rule_check(argparse.Namespace()) == 0
+        cli.account_manager.switch_account.assert_not_called()
+
+    def test_handle_rule_check_switches_when_mismatched(self, cli):
+        cli.account_manager.rules_manager.find_matching_account.return_value = "work"
+        cli.account_manager.account_exists.return_value = True
+        cli.account_manager.get_status.return_value = {"matched_account": "personal"}
+        cli.account_manager.ssh_manager.is_ssh_agent_running.return_value = True
+        cli.account_manager.switch_account.return_value = True
+        assert cli._handle_rule_check(argparse.Namespace()) == 0
+        cli.account_manager.switch_account.assert_called_once_with("work")
+
+    def test_handle_rule_check_switch_failure(self, cli):
+        cli.account_manager.rules_manager.find_matching_account.return_value = "work"
+        cli.account_manager.account_exists.return_value = True
+        cli.account_manager.get_status.return_value = {"matched_account": "personal"}
+        cli.account_manager.ssh_manager.is_ssh_agent_running.return_value = True
+        cli.account_manager.switch_account.return_value = False
+        assert cli._handle_rule_check(argparse.Namespace()) == 1

gitacc_switcher-1.4.0/tests/test_rules_manager.py

@@ -0,0 +1,142 @@
+"""Tests for directory-based auto-switch rule storage and lookup."""
+
+from gitacc_switcher.rules_manager import RulesManager
+
+
+def make_manager(tmp_path):
+    return RulesManager(rules_file=tmp_path / ".gitaccrules")
+
+
+class TestListRules:
+    def test_empty_when_file_missing(self, tmp_path):
+        manager = make_manager(tmp_path)
+        assert manager.list_rules() == {}
+
+    def test_reads_added_entries(self, tmp_path):
+        manager = make_manager(tmp_path)
+        work_dir = tmp_path / "work"
+        work_dir.mkdir()
+        manager.add_rule(work_dir, "work")
+
+        rules = manager.list_rules()
+        assert rules == {str(work_dir.resolve()): "work"}
+
+    def test_ignores_blank_lines_and_comments(self, tmp_path):
+        rules_file = tmp_path / ".gitaccrules"
+        rules_file.write_text("\n# a comment\n" + f"{tmp_path} = personal\n" + "\n")
+        manager = RulesManager(rules_file=rules_file)
+
+        assert manager.list_rules() == {str(tmp_path): "personal"}
+
+
+class TestAddRule:
+    def test_creates_file_when_missing(self, tmp_path):
+        manager = make_manager(tmp_path)
+        assert not manager.rules_file.exists()
+
+        assert manager.add_rule(tmp_path, "work") is True
+        assert manager.rules_file.exists()
+
+    def test_normalizes_relative_path(self, tmp_path, monkeypatch):
+        sub_dir = tmp_path / "project"
+        sub_dir.mkdir()
+        monkeypatch.chdir(tmp_path)
+
+        manager = RulesManager(rules_file=tmp_path / "rules")
+        manager.add_rule("project", "work")
+
+        assert manager.list_rules() == {str(sub_dir.resolve()): "work"}
+
+    def test_updates_existing_rule_for_same_directory(self, tmp_path):
+        manager = make_manager(tmp_path)
+        manager.add_rule(tmp_path, "work")
+        manager.add_rule(tmp_path, "personal")
+
+        rules = manager.list_rules()
+        assert rules[str(tmp_path.resolve())] == "personal"
+        assert len(rules) == 1
+
+    def test_supports_multiple_directories(self, tmp_path):
+        manager = make_manager(tmp_path)
+        work_dir = tmp_path / "work"
+        personal_dir = tmp_path / "personal"
+        work_dir.mkdir()
+        personal_dir.mkdir()
+
+        manager.add_rule(work_dir, "work")
+        manager.add_rule(personal_dir, "personal")
+
+        rules = manager.list_rules()
+        assert rules[str(work_dir.resolve())] == "work"
+        assert rules[str(personal_dir.resolve())] == "personal"
+
+
+class TestRemoveRule:
+    def test_removes_existing_rule(self, tmp_path):
+        manager = make_manager(tmp_path)
+        manager.add_rule(tmp_path, "work")
+
+        assert manager.remove_rule(tmp_path) is True
+        assert manager.list_rules() == {}
+
+    def test_returns_false_when_no_rule_exists(self, tmp_path):
+        manager = make_manager(tmp_path)
+        assert manager.remove_rule(tmp_path) is False
+
+    def test_leaves_other_rules_intact(self, tmp_path):
+        manager = make_manager(tmp_path)
+        work_dir = tmp_path / "work"
+        personal_dir = tmp_path / "personal"
+        work_dir.mkdir()
+        personal_dir.mkdir()
+        manager.add_rule(work_dir, "work")
+        manager.add_rule(personal_dir, "personal")
+
+        manager.remove_rule(work_dir)
+
+        rules = manager.list_rules()
+        assert str(work_dir.resolve()) not in rules
+        assert rules[str(personal_dir.resolve())] == "personal"
+
+
+class TestFindMatchingAccount:
+    def test_no_match_when_no_rules(self, tmp_path):
+        manager = make_manager(tmp_path)
+        assert manager.find_matching_account(tmp_path) is None
+
+    def test_exact_directory_match(self, tmp_path):
+        manager = make_manager(tmp_path)
+        manager.add_rule(tmp_path, "work")
+
+        assert manager.find_matching_account(tmp_path) == "work"
+
+    def test_subdirectory_matches_parent_rule(self, tmp_path):
+        manager = make_manager(tmp_path)
+        work_dir = tmp_path / "work"
+        nested = work_dir / "repo" / "src"
+        nested.mkdir(parents=True)
+        manager.add_rule(work_dir, "work")
+
+        assert manager.find_matching_account(nested) == "work"
+
+    def test_unrelated_directory_does_not_match(self, tmp_path):
+        manager = make_manager(tmp_path)
+        work_dir = tmp_path / "work"
+        other_dir = tmp_path / "other"
+        work_dir.mkdir()
+        other_dir.mkdir()
+        manager.add_rule(work_dir, "work")
+
+        assert manager.find_matching_account(other_dir) is None
+
+    def test_most_specific_rule_wins(self, tmp_path):
+        manager = make_manager(tmp_path)
+        work_dir = tmp_path / "work"
+        client_dir = work_dir / "client-a"
+        client_dir.mkdir(parents=True)
+        manager.add_rule(work_dir, "work")
+        manager.add_rule(client_dir, "client-a")
+
+        assert manager.find_matching_account(client_dir) == "client-a"
+        assert manager.find_matching_account(work_dir) == "work"
+        assert manager.find_matching_account(client_dir / "src") == "client-a"

gitacc_switcher-1.4.0/tests/test_shell_hook.py

@@ -0,0 +1,34 @@
+"""Tests for shell hook snippet generation."""
+
+from gitacc_switcher.shell_hook import get_hook_script, get_supported_shells
+
+
+class TestGetHookScript:
+    def test_bash_hook_calls_rule_check(self):
+        script = get_hook_script("bash")
+        assert script is not None
+        assert "gitacc rule check" in script
+        assert "PROMPT_COMMAND" in script
+
+    def test_zsh_hook_calls_rule_check(self):
+        script = get_hook_script("zsh")
+        assert script is not None
+        assert "gitacc rule check" in script
+        assert "chpwd_functions" in script
+
+    def test_is_case_insensitive(self):
+        assert get_hook_script("Bash") == get_hook_script("bash")
+
+    def test_unsupported_shell_returns_none(self):
+        assert get_hook_script("fish") is None
+
+
+class TestGetSupportedShells:
+    def test_includes_bash_and_zsh(self):
+        shells = get_supported_shells()
+        assert "bash" in shells
+        assert "zsh" in shells
+
+    def test_every_supported_shell_has_a_script(self):
+        for shell in get_supported_shells():
+            assert get_hook_script(shell)