git-repokit 0.9.10__py3-none-any.whl

repokit/git_config.py

@@ -0,0 +1,370 @@
+#!/usr/bin/env python3
+"""
+Git Configuration Manager for RepoKit
+
+Enhanced git configuration detection with multi-level cascade support.
+Provides comprehensive user.name and user.email detection across different
+git config levels.
+"""
+
+import os
+import subprocess
+import logging
+from typing import Dict, Optional, Any
+
+
+class GitConfigManager:
+    """
+    Manages git configuration detection with multi-level cascade support.
+
+    Detection levels (in order of precedence):
+    1. Repository-specific config (.git/config)
+    2. Global user config (~/.gitconfig)
+    3. System config (/etc/gitconfig)
+    4. Environment variables
+    5. Interactive prompts (if enabled)
+    """
+
+    def __init__(self, repo_path: Optional[str] = None, verbose: int = 0):
+        """
+        Initialize GitConfigManager.
+
+        Args:
+            repo_path: Path to git repository (for repo-specific config)
+            verbose: Verbosity level for logging
+        """
+        self.repo_path = repo_path
+        self.verbose = verbose
+        self.logger = logging.getLogger("repokit.git_config")
+
+    def get_comprehensive_user_info(self, interactive: bool = True) -> Dict[str, str]:
+        """
+        Get git user information using comprehensive detection cascade.
+
+        Args:
+            interactive: Whether to prompt user if information is missing
+
+        Returns:
+            Dictionary with 'name' and 'email' keys
+        """
+        user_info = {}
+
+        # Level 1: Repository-specific config
+        if self.repo_path:
+            repo_config = self._get_repo_git_config()
+            user_info.update(repo_config)
+            if self.verbose >= 2:
+                self.logger.debug(f"Repository config: {repo_config}")
+
+        # Level 2: Global git config (if missing data)
+        if not user_info.get('name') or not user_info.get('email'):
+            global_config = self._get_global_git_config()
+            for key, value in global_config.items():
+                if not user_info.get(key):
+                    user_info[key] = value
+            if self.verbose >= 2:
+                self.logger.debug(f"Global config: {global_config}")
+
+        # Level 3: System git config (if still missing data)
+        if not user_info.get('name') or not user_info.get('email'):
+            system_config = self._get_system_git_config()
+            for key, value in system_config.items():
+                if not user_info.get(key):
+                    user_info[key] = value
+            if self.verbose >= 2:
+                self.logger.debug(f"System config: {system_config}")
+
+        # Level 4: Environment variables
+        if not user_info.get('name') or not user_info.get('email'):
+            env_config = self._get_env_git_config()
+            for key, value in env_config.items():
+                if not user_info.get(key):
+                    user_info[key] = value
+            if self.verbose >= 2:
+                self.logger.debug(f"Environment config: {env_config}")
+
+        # Level 5: Interactive prompts (if enabled and data still missing)
+        missing_info = (not user_info.get('name') or
+                        not user_info.get('email'))
+        if interactive and missing_info:
+            interactive_config = self._prompt_for_git_config(user_info)
+            user_info.update(interactive_config)
+            if self.verbose >= 2:
+                self.logger.debug(f"Interactive config: {interactive_config}")
+
+        # Log final result
+        if self.verbose >= 1:
+            name = user_info.get('name', 'NOT SET')
+            email = user_info.get('email', 'NOT SET')
+            self.logger.info(f"Final git user config: name='{name}', "
+                            f"email='{email}'")
+
+        return user_info
+
+    def _get_repo_git_config(self) -> Dict[str, str]:
+        """Get user config from repository-specific .git/config."""
+        if not self.repo_path:
+            return {}
+        
+        git_path = os.path.join(self.repo_path, ".git")
+        if not os.path.exists(git_path):
+            return {}
+
+        config = {}
+
+        # Get user.name from repo config
+        try:
+            result = subprocess.run(
+                ["git", "config", "--local", "user.name"],
+                cwd=self.repo_path,
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                config["name"] = result.stdout.strip()
+        except Exception as e:
+            if self.verbose >= 3:
+                self.logger.debug(f"Failed to get repo user.name: {e}")
+
+        # Get user.email from repo config
+        try:
+            result = subprocess.run(
+                ["git", "config", "--local", "user.email"],
+                cwd=self.repo_path,
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                config["email"] = result.stdout.strip()
+        except Exception as e:
+            if self.verbose >= 3:
+                self.logger.debug(f"Failed to get repo user.email: {e}")
+
+        return config
+
+    def _get_global_git_config(self) -> Dict[str, str]:
+        """Get user config from global ~/.gitconfig."""
+        config = {}
+
+        # Get user.name from global config
+        try:
+            result = subprocess.run(
+                ["git", "config", "--global", "user.name"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                config["name"] = result.stdout.strip()
+        except Exception as e:
+            if self.verbose >= 3:
+                self.logger.debug(f"Failed to get global user.name: {e}")
+
+        # Get user.email from global config
+        try:
+            result = subprocess.run(
+                ["git", "config", "--global", "user.email"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                config["email"] = result.stdout.strip()
+        except Exception as e:
+            if self.verbose >= 3:
+                self.logger.debug(f"Failed to get global user.email: {e}")
+
+        return config
+
+    def _get_system_git_config(self) -> Dict[str, str]:
+        """Get user config from system /etc/gitconfig."""
+        config = {}
+
+        # Get user.name from system config
+        try:
+            result = subprocess.run(
+                ["git", "config", "--system", "user.name"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                config["name"] = result.stdout.strip()
+        except Exception as e:
+            if self.verbose >= 3:
+                self.logger.debug(f"Failed to get system user.name: {e}")
+
+        # Get user.email from system config
+        try:
+            result = subprocess.run(
+                ["git", "config", "--system", "user.email"],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                config["email"] = result.stdout.strip()
+        except Exception as e:
+            if self.verbose >= 3:
+                self.logger.debug(f"Failed to get system user.email: {e}")
+
+        return config
+
+    def _get_env_git_config(self) -> Dict[str, str]:
+        """Get user config from environment variables."""
+        config = {}
+
+        # Check for git-specific environment variables
+        if os.environ.get('GIT_AUTHOR_NAME'):
+            config["name"] = os.environ['GIT_AUTHOR_NAME']
+        elif os.environ.get('GIT_COMMITTER_NAME'):
+            config["name"] = os.environ['GIT_COMMITTER_NAME']
+
+        if os.environ.get('GIT_AUTHOR_EMAIL'):
+            config["email"] = os.environ['GIT_AUTHOR_EMAIL']
+        elif os.environ.get('GIT_COMMITTER_EMAIL'):
+            config["email"] = os.environ['GIT_COMMITTER_EMAIL']
+
+        # Check for RepoKit-specific environment variables
+        if os.environ.get('REPOKIT_USER_NAME'):
+            config["name"] = os.environ['REPOKIT_USER_NAME']
+
+        if os.environ.get('REPOKIT_USER_EMAIL'):
+            config["email"] = os.environ['REPOKIT_USER_EMAIL']
+
+        return config
+
+    def _prompt_for_git_config(self, existing_config: Dict[str, str]) -> Dict[str, str]:
+        """
+        Interactively prompt user for missing git configuration.
+
+        Args:
+            existing_config: Already detected configuration
+
+        Returns:
+            Dictionary with user-provided values
+        """
+        config = {}
+
+        try:
+            # Prompt for name if missing
+            if not existing_config.get('name'):
+                print("\n" + "="*60)
+                print("Git User Configuration Required")
+                print("="*60)
+                print("RepoKit needs your git user information for commits "
+                      "and templates.")
+                print("This will be saved to your project's .repokit.json file.")
+                print()
+
+                name = input("Enter your full name (for git commits): ").strip()
+                if name:
+                    config["name"] = name
+
+            # Prompt for email if missing
+            if not existing_config.get('email'):
+                if not existing_config.get('name'):
+                    print()  # Add spacing if we already prompted for name
+
+                email = input("Enter your email address (for git commits): ").strip()
+                if email:
+                    config["email"] = email
+
+            if config:
+                print()
+                print("✓ Configuration collected. This will be saved for future use.")
+                print("="*60)
+
+        except (KeyboardInterrupt, EOFError):
+            # User cancelled input
+            if self.verbose >= 1:
+                self.logger.info("User cancelled git config input")
+
+        return config
+
+    def get_template_context(self, base_context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Get enhanced template context with git user information.
+
+        Args:
+            base_context: Existing template context to enhance
+
+        Returns:
+            Enhanced context dictionary with git user info
+        """
+        context = base_context.copy() if base_context else {}
+
+        # Get comprehensive user info
+        user_info = self.get_comprehensive_user_info(interactive=False)
+
+        # Add git-specific template variables
+        context.update({
+            'author': user_info.get('name', 'Unknown Author'),
+            'author_email': user_info.get('email', 'unknown@example.com'),
+            'git_user_name': user_info.get('name'),
+            'git_user_email': user_info.get('email'),
+
+            # Backwards compatibility
+            'user_name': user_info.get('name'),
+            'user_email': user_info.get('email'),
+        })
+
+        return context
+
+    def configure_repo_git_user(self, user_info: Optional[Dict[str, str]] = None) -> bool:
+        """
+        Configure git user settings in the repository.
+
+        Args:
+            user_info: User info dict, or None to detect automatically
+
+        Returns:
+            True if configuration was successful
+        """
+        if not self.repo_path:
+            self.logger.warning("Cannot configure git user: no repository path")
+            return False
+        
+        git_path = os.path.join(self.repo_path, ".git")
+        if not os.path.exists(git_path):
+            self.logger.warning("Cannot configure git user: not a git repository")
+            return False
+
+        if not user_info:
+            user_info = self.get_comprehensive_user_info(interactive=True)
+
+        success = True
+
+        # Configure user.name
+        if user_info.get('name'):
+            try:
+                subprocess.run(
+                    ["git", "config", "user.name", user_info['name']],
+                    cwd=self.repo_path,
+                    check=True,
+                    capture_output=True
+                )
+                if self.verbose >= 1:
+                    self.logger.info(f"Set git user.name to: {user_info['name']}")
+            except subprocess.CalledProcessError as e:
+                self.logger.error(f"Failed to set git user.name: {e}")
+                success = False
+
+        # Configure user.email
+        if user_info.get('email'):
+            try:
+                subprocess.run(
+                    ["git", "config", "user.email", user_info['email']],
+                    cwd=self.repo_path,
+                    check=True,
+                    capture_output=True
+                )
+                if self.verbose >= 1:
+                    self.logger.info(f"Set git user.email to: {user_info['email']}")
+            except subprocess.CalledProcessError as e:
+                self.logger.error(f"Failed to set git user.email: {e}")
+                success = False
+
+        return success

repokit/github_create.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+"""
+`repokit create --github`: the repository on GitHub, through the gh CLI.
+
+gh holds the login (`gh auth login`), so git-repokit never handles a token on
+this path -- the ease the GitHub template used to give, where GitHub made the
+repository and the tooling only configured it (djdarcy, 2026-10-07).
+
+Only public branches are pushed: in the private-branch model the private
+branch never leaves the machine, so `gh repo create --push` (which pushes the
+current branch -- the private one there) is not used; branches are pushed
+explicitly.
+"""
+
+import os
+import shutil
+import subprocess
+import sys
+from typing import List, Optional, Tuple
+
+from .defaults import strategy_push_branches
+
+GH_ENV = "REPOKIT_GH"  # override the gh executable (tests use a stub)
+
+
+def gh_command() -> Optional[List[str]]:
+    override = os.environ.get(GH_ENV)
+    if override:
+        return [sys.executable, override] if override.endswith(".py") else [override]
+    found = shutil.which("gh")
+    return [found] if found else None
+
+
+def _run(cmd: List[str], cwd: str) -> Tuple[int, str]:
+    try:
+        result = subprocess.run(cmd, cwd=cwd, capture_output=True, text=True,
+                                encoding="utf-8", errors="replace")
+    except OSError as e:  # the executable does not exist or cannot run
+        return 127, str(e)
+    return result.returncode, (result.stdout + result.stderr).strip()
+
+
+def gh_login(cwd: str) -> Optional[str]:
+    """The account gh is logged into, or None when gh is absent, logged out or
+    unreadable. Read before any file is written (0.9.6), so the project's URLs,
+    CODEOWNERS and FUNDING carry the real owner rather than a placeholder;
+    create_on_github still checks the login itself and reports any problem."""
+    gh = gh_command()
+    if gh is None:
+        return None
+    rc, out = _run(gh + ["api", "user", "-q", ".login"], cwd)
+    login = out.splitlines()[-1].strip() if rc == 0 and out else ""
+    return login or None
+
+
+def branches_to_push(config: dict, private_branch: Optional[str], existing: List[str]) -> List[str]:
+    """The strategy's public branches that exist locally; never the private branch."""
+    wanted = strategy_push_branches(config.get("branch_strategy", "main-only")) or ["main"]
+    return [b for b in wanted if b in existing and b != private_branch]
+
+
+def create_on_github(repo_root: str, name: str, config: dict, private_branch: Optional[str],
+                     organization: Optional[str] = None, public: bool = False,
+                     logger=None, report: Optional[List[str]] = None) -> Optional[str]:
+    """Create <owner>/<name> on GitHub, run the GitHub-half steps the config
+    names (`github_setup`, 0.9.3: labels and the two issues before the push,
+    the rest after), and push the public branches.
+
+    Returns None on success, or what went wrong (the local repository is
+    left as it is either way). The steps' report lines go into ``report``.
+    """
+    from . import github_setup
+    steps = github_setup.setup_names(config.get("github_setup"))
+    report = report if report is not None else []
+
+    gh = gh_command()
+    if gh is None:
+        return "gh (the GitHub CLI) is not installed; see https://cli.github.com"
+
+    rc, out = _run(gh + ["auth", "status"], repo_root)
+    if rc != 0:
+        return f"gh is not logged in (run `gh auth login`): {out}"
+
+    rc, out = _run(gh + ["api", "user", "-q", ".login"], repo_root)
+    login = out.splitlines()[-1].strip() if rc == 0 and out else None
+    if not organization and not login:
+        return f"could not read the GitHub user from gh: {out}"
+    # Refuse on another account: the config names the person's handle, and gh
+    # is logged into someone else (0.9.3).
+    github_cfg = config.get("github") if isinstance(config.get("github"), dict) else {}
+    configured = (github_cfg or {}).get("username")
+    if configured and login and configured.lower() != login.lower():
+        return (f"gh is logged into {login!r} but the config's github.username is {configured!r}; "
+                "switch with `gh auth switch` or fix the config")
+    owner = organization or login
+
+    create = gh + ["repo", "create", f"{owner}/{name}",
+                   "--public" if public else "--private",
+                   "--source", repo_root, "--remote", "origin"]
+    description = config.get("description")
+    if description:
+        create += ["--description", description]
+    rc, out = _run(create, repo_root)
+    if rc != 0:
+        return f"gh repo create failed: {out}"
+    if logger:
+        logger.info(f"Created {owner}/{name} on GitHub ({'public' if public else 'private'})")
+
+    # Before the first push: the labels and the two issues, so they are #1 and #2.
+    setup = github_setup.GhSetup(gh, f"{owner}/{name}", lambda cmd: _run(cmd, repo_root))
+    project = config.get("name") or name
+    if "labels" in steps:
+        report += setup.labels(github_setup.referenced_labels(repo_root))
+    if "issues" in steps:
+        drafts = os.path.join(repo_root, "private", "claude", "issues")
+        report += setup.issues(project, drafts if os.path.isdir(drafts) else None)
+    if "pin" in steps:
+        report += setup.pin()
+
+    rc, out = _run(["git", "for-each-ref", "--format=%(refname:short)", "refs/heads"], repo_root)
+    existing = out.split()
+    pushed = []
+    for branch in branches_to_push(config, private_branch, existing):
+        rc, out = _run(["git", "push", "-u", "origin", branch], repo_root)
+        if rc != 0:
+            return f"git push of '{branch}' failed: {out}"
+        pushed.append(branch)
+    if logger:
+        logger.info(f"Pushed: {', '.join(pushed) or 'nothing'}")
+
+    # After the push: the settings that need the repository's content or no ordering.
+    if "discussions" in steps:
+        report += setup.discussions()
+    if "topics" in steps:
+        report += setup.topics(list(config.get("topics") or []))
+    if "pypi-environment" in steps:
+        report += setup.pypi_environment(config.get("archetype"))
+    if "traffic" in steps:
+        report += setup.traffic(project)
+    if steps:
+        report += github_setup.reminders(f"{owner}/{name}", list(config.get("extras") or []))
+    return None