markdown-table-fixer 0.1.0__tar.gz → 0.1.2__tar.gz

{markdown_table_fixer-0.1.0 → markdown_table_fixer-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markdown-table-fixer
-Version: 0.1.0
+Version: 0.1.2
 Summary: Markdown table formatter and linter with GitHub integration
 Project-URL: Homepage, https://github.com/lfit/markdown-table-fixer
 Project-URL: Repository, https://github.com/lfit/markdown-table-fixer.git
@@ -123,6 +123,34 @@ Dry run to preview changes without applying them:
 markdown-table-fixer github https://github.com/owner/repo/pull/123 --dry-run
 ```
 
+#### Update Methods
+
+The tool supports two methods for applying fixes:
+
+**API Method (default)** - Uses GitHub API to create new commits:
+
+```bash
+markdown-table-fixer github https://github.com/owner/repo/pull/123
+```
+
+- Creates new commits via GitHub API
+- Shows as "Verified" by GitHub
+- No Git operations required
+- Faster and simpler
+- Does not support sync strategies (rebase/merge)
+
+**Git Method** - Clones repo, amends commit, force-pushes:
+
+```bash
+markdown-table-fixer github https://github.com/owner/repo/pull/123 \
+  --update-method git
+```
+
+- Respects your local Git signing configuration
+- Amends the existing commit (preserves commit history)
+- Requires Git operations (clone, amend, push)
+- Use when you need to amend commits or use sync strategies
+
 #### Fix PRs Across an Organization
 
 Scan and fix tables in PRs across an entire GitHub organization:

{markdown_table_fixer-0.1.0 → markdown_table_fixer-0.1.2}/README.md

@@ -82,6 +82,34 @@ Dry run to preview changes without applying them:
 markdown-table-fixer github https://github.com/owner/repo/pull/123 --dry-run
 ```
 
+#### Update Methods
+
+The tool supports two methods for applying fixes:
+
+**API Method (default)** - Uses GitHub API to create new commits:
+
+```bash
+markdown-table-fixer github https://github.com/owner/repo/pull/123
+```
+
+- Creates new commits via GitHub API
+- Shows as "Verified" by GitHub
+- No Git operations required
+- Faster and simpler
+- Does not support sync strategies (rebase/merge)
+
+**Git Method** - Clones repo, amends commit, force-pushes:
+
+```bash
+markdown-table-fixer github https://github.com/owner/repo/pull/123 \
+  --update-method git
+```
+
+- Respects your local Git signing configuration
+- Amends the existing commit (preserves commit history)
+- Requires Git operations (clone, amend, push)
+- Use when you need to amend commits or use sync strategies
+
 #### Fix PRs Across an Organization
 
 Scan and fix tables in PRs across an entire GitHub organization:

{markdown_table_fixer-0.1.0 → markdown_table_fixer-0.1.2}/pyproject.toml

@@ -136,6 +136,18 @@ module = ["tests.*"]
 disallow_untyped_decorators = false
 disallow_untyped_defs = false
 
+[[tool.mypy.overrides]]
+module = ["typer.*"]
+disallow_untyped_decorators = false
+
+[[tool.mypy.overrides]]
+module = ["tenacity.*"]
+disallow_untyped_decorators = false
+
+[[tool.mypy.overrides]]
+module = ["wcwidth"]
+ignore_missing_imports = true
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 python_files = ["test_*.py", "*_test.py"]

{markdown_table_fixer-0.1.0 → markdown_table_fixer-0.1.2}/src/markdown_table_fixer/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.0'
-__version_tuple__ = version_tuple = (0, 1, 0)
+__version__ = version = '0.1.2'
+__version_tuple__ = version_tuple = (0, 1, 2)
 
 __commit_id__ = commit_id = None

{markdown_table_fixer-0.1.0 → markdown_table_fixer-0.1.2}/src/markdown_table_fixer/cli.py

@@ -9,20 +9,17 @@ import asyncio
 import json
 import logging
 from pathlib import Path
-from typing import TYPE_CHECKING
 
 from rich.console import Console
 from rich.logging import RichHandler
 import typer
 
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
 from ._version import __version__
 from .exceptions import (
     FileAccessError,
     TableParseError,
 )
+from .git_config import GitConfigMode
 from .github_client import GitHubClient
 from .models import (
     BlockedPR,
@@ -42,10 +39,15 @@ from .table_validator import TableValidator
 console = Console()
 
 
+def get_version_string() -> str:
+    """Get the formatted version string."""
+    return f"🏷️  markdown-table-fixer version {__version__}"
+
+
 def version_callback(value: bool) -> None:
     """Show version and exit."""
     if value:
-        console.print(f"🏷️  markdown-table-fixer version {__version__}")
+        console.print(get_version_string())
         console.print()
         raise typer.Exit()
 
@@ -71,28 +73,30 @@ def setup_logging(
     logging.getLogger("httpx").setLevel(logging.WARNING)
 
 
-# Create Typer app with version in help
-app = typer.Typer(
+# Create Typer app with custom help formatter
+class CustomTyper(typer.Typer):
+    """Custom Typer class to add version to help output."""
+
+    def __call__(self, *args: object, **kwargs: object) -> object:
+        """Override to inject version string in help output."""
+        # Check if help is being requested (for any command or subcommand)
+        import sys
+
+        if "--help" in sys.argv or "-h" in sys.argv:
+            console.print(get_version_string())
+        return super().__call__(*args, **kwargs)
+
+
+# Create Typer app
+app = CustomTyper(
     name="markdown-table-fixer",
-    help=f"markdown-table-fixer version {__version__}\n\nFix markdown table formatting issues",
+    help="Fix markdown table formatting issues",
     add_completion=False,
     rich_markup_mode="rich",
 )
 
 
-# Update command docstrings with version at module load time
-def _add_version_to_docstring(
-    cmd_func: Callable[..., None],
-) -> Callable[..., None]:
-    """Add version info to command docstring."""
-    if cmd_func.__doc__:
-        cmd_func.__doc__ = (
-            f"markdown-table-fixer version {__version__}\n\n" + cmd_func.__doc__
-        )
-    return cmd_func
-
-
-@app.callback()  # type: ignore[misc]
+@app.callback()
 def main(
     version: bool = typer.Option(
         False,
@@ -106,8 +110,7 @@ def main(
     pass
 
 
-@app.command()  # type: ignore[misc]
-@_add_version_to_docstring  # type: ignore[misc]
+@app.command(help="Scan and optionally fix markdown table formatting issues")
 def lint(
     path: Path = typer.Argument(
         Path("."),
@@ -131,13 +134,6 @@ def lint(
         "--check",
         help="Exit with error if issues found (CI mode)",
     ),
-    _version: bool = typer.Option(
-        False,
-        "--version",
-        help="Show version and exit",
-        callback=version_callback,
-        is_eager=True,
-    ),
     max_line_length: int = typer.Option(
         80,
         "--max-line-length",
@@ -215,8 +211,7 @@ def lint(
         raise typer.Exit(1) from e
 
 
-@app.command()  # type: ignore[misc]
-@_add_version_to_docstring  # type: ignore[misc]
+@app.command(help="Fix markdown tables in GitHub pull requests")
 def github(
     target: str = typer.Argument(
         ...,
@@ -241,6 +236,22 @@ def github(
         help="How to resolve conflicts: 'fail', 'ours' (keep PR changes), or 'theirs' (keep base changes)",
         case_sensitive=False,
     ),
+    update_method: str = typer.Option(
+        "api",
+        "--update-method",
+        help="Method to apply fixes: 'git' (clone, amend, push) or 'api' (GitHub API commits, default)",
+        case_sensitive=False,
+    ),
+    no_user_signing: bool = typer.Option(
+        False,
+        "--no-user-signing",
+        help="Use user identity but disable commit signing (only applies to 'git' method)",
+    ),
+    bot_identity: bool = typer.Option(
+        False,
+        "--bot-identity",
+        help="Use bot identity without signing (only applies to 'git' method)",
+    ),
     dry_run: bool = typer.Option(
         False,
         "--dry-run",
@@ -281,13 +292,6 @@ def github(
         "--log-level",
         help="Set logging level",
     ),
-    _version: bool = typer.Option(
-        False,
-        "--version",
-        help="Show version and exit",
-        callback=version_callback,
-        is_eager=True,
-    ),
 ) -> None:
     """Fix markdown tables in GitHub PRs.
 
@@ -295,7 +299,16 @@ def github(
     - An entire organization (scans all PRs for table issues)
     - A specific PR by URL
 
-    Sync strategies:
+    Update Methods:
+    - 'api' (default): Use GitHub API to create new commits (shows as verified by GitHub)
+    - 'git': Clone repo, amend commit, force-push (respects signing)
+
+    Git Identity & Signing (only applies to 'git' update method):
+    - By default, uses your git user.name, user.email, and commit signing settings
+    - --no-user-signing: Use your identity but disable commit signing
+    - --bot-identity: Use bot identity without signing
+
+    Sync strategies (only applies to 'git' update method):
     - 'none': Fix tables on PR branch as-is (may have conflicts)
     - 'rebase': Rebase PR onto base branch before fixing (cleaner history)
     - 'merge': Merge base branch into PR before fixing (safer)
@@ -313,16 +326,41 @@ def github(
     """
     setup_logging(log_level=log_level, quiet=quiet, verbose=verbose)
 
-    # Validate sync strategy
-    if sync_strategy.lower() not in ["none", "rebase", "merge"]:
+    # Normalize and validate update method
+    update_method = update_method.lower()
+    if update_method not in ["git", "api"]:
+        console.print(
+            f"[red]Error:[/red] Invalid update method '{update_method}'. "
+            "Use 'git' or 'api'"
+        )
+        raise typer.Exit(1)
+
+    # Determine git config mode from CLI flags (only relevant for git method)
+    if bot_identity and no_user_signing:
+        console.print(
+            "[red]Error:[/red] Cannot use both --bot-identity and --no-user-signing"
+        )
+        raise typer.Exit(1)
+
+    if bot_identity:
+        git_config_mode = GitConfigMode.BOT_IDENTITY
+    elif no_user_signing:
+        git_config_mode = GitConfigMode.USER_NO_SIGN
+    else:
+        git_config_mode = GitConfigMode.USER_INHERIT
+
+    # Normalize and validate sync strategy
+    sync_strategy = sync_strategy.lower()
+    if sync_strategy not in ["none", "rebase", "merge"]:
         console.print(
             f"[red]Error:[/red] Invalid sync strategy '{sync_strategy}'. "
             "Use 'none', 'rebase', or 'merge'"
         )
         raise typer.Exit(1)
 
-    # Validate conflict strategy
-    if conflict_strategy.lower() not in ["fail", "ours", "theirs"]:
+    # Normalize and validate conflict strategy
+    conflict_strategy = conflict_strategy.lower()
+    if conflict_strategy not in ["fail", "ours", "theirs"]:
         console.print(
             f"[red]Error:[/red] Invalid conflict strategy '{conflict_strategy}'. "
             "Use 'fail', 'ours', or 'theirs'"
@@ -343,10 +381,12 @@ def github(
             _fix_single_pr(
                 target,
                 token,
-                sync_strategy=sync_strategy.lower(),
-                conflict_strategy=conflict_strategy.lower(),
+                sync_strategy=sync_strategy,
+                conflict_strategy=conflict_strategy,
                 dry_run=dry_run,
                 quiet=quiet,
+                git_config_mode=git_config_mode,
+                update_method=update_method,
             )
         )
     else:
@@ -355,12 +395,14 @@ def github(
             _scan_organization(
                 target,
                 token,
-                sync_strategy=sync_strategy.lower(),
-                conflict_strategy=conflict_strategy.lower(),
+                sync_strategy=sync_strategy,
+                conflict_strategy=conflict_strategy,
                 dry_run=dry_run,
                 include_drafts=include_drafts,
                 debug_org=debug_org,
                 quiet=quiet,
+                git_config_mode=git_config_mode,
+                update_method=update_method,
             )
         )
 
@@ -372,6 +414,8 @@ async def _fix_single_pr(
     conflict_strategy: str = "fail",
     dry_run: bool = False,
     quiet: bool = False,
+    git_config_mode: str = GitConfigMode.USER_INHERIT,
+    update_method: str = "api",
 ) -> None:
     """Fix markdown tables in a single PR."""
     if not quiet:
@@ -379,12 +423,13 @@ async def _fix_single_pr(
 
     try:
         async with GitHubClient(token) as client:  # type: ignore[attr-defined]
-            fixer = PRFixer(client)
+            fixer = PRFixer(client, git_config_mode=git_config_mode)
             result = await fixer.fix_pr_by_url(  # type: ignore[attr-defined]
                 pr_url,
                 sync_strategy=sync_strategy,
                 conflict_strategy=conflict_strategy,
                 dry_run=dry_run,
+                update_method=update_method,
             )
 
             if result.success:
@@ -412,6 +457,8 @@ async def _scan_organization(
     include_drafts: bool = False,
     debug_org: bool = False,
     quiet: bool = False,
+    git_config_mode: str = GitConfigMode.USER_INHERIT,
+    update_method: str = "api",
 ) -> None:
     """Scan organization for PRs with markdown table issues."""
     # Remove github.com prefix if present
@@ -429,7 +476,28 @@ async def _scan_organization(
             )
 
             scanner = PRScanner(client, progress_tracker=progress_tracker)
-            fixer = PRFixer(client)
+            fixer = PRFixer(client, git_config_mode=git_config_mode)
+
+            # Inform about update method
+            if not quiet:
+                method_desc = (
+                    "Git clone/amend/push"
+                    if update_method.lower() == "git"
+                    else "GitHub API commits"
+                )
+                console.print(f"Update method: {method_desc}")
+                if update_method.lower() == "git":
+                    if git_config_mode == GitConfigMode.BOT_IDENTITY:
+                        console.print(
+                            "Git identity: Bot (markdown-table-fixer)"
+                        )
+                    elif git_config_mode == GitConfigMode.USER_NO_SIGN:
+                        console.print("Git identity: User (signing disabled)")
+                    else:
+                        console.print(
+                            "Git identity: User (inheriting signing config)"
+                        )
+                console.print()
 
             # Collect PRs from async generator
             prs_to_process = []
@@ -537,6 +605,7 @@ async def _scan_organization(
                         sync_strategy=sync_strategy,
                         conflict_strategy=conflict_strategy,
                         dry_run=dry_run,
+                        update_method=update_method,
                     )
 
                     if result.success:

markdown_table_fixer-0.1.2/src/markdown_table_fixer/git_config.py

@@ -0,0 +1,303 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2025 The Linux Foundation
+
+"""Git configuration management for commit signing and user identity."""
+
+from __future__ import annotations
+
+from enum import Enum
+import logging
+from pathlib import Path  # noqa: TC003
+import subprocess
+
+logger = logging.getLogger(__name__)
+
+
+class GitConfigMode(str, Enum):
+    """Git configuration modes."""
+
+    USER_INHERIT = (
+        "user_inherit"  # Inherit user's full config including signing
+    )
+    USER_NO_SIGN = "user_no_sign"  # Use user identity but disable signing
+    BOT_IDENTITY = "bot_identity"  # Use bot identity without signing
+
+
+def _get_global_git_config(key: str) -> str | None:
+    """Get a value from global git config.
+
+    Args:
+        key: Git config key (e.g., "user.name")
+
+    Returns:
+        Config value or None if not set
+    """
+    try:
+        result = subprocess.run(
+            ["git", "config", "--global", key],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode == 0:
+            value = result.stdout.strip()
+            return value if value else None
+        return None
+    except Exception as e:
+        logger.debug(f"Could not get git config {key}: {e}")
+        return None
+
+
+def _set_repo_git_config(repo_dir: Path, key: str, value: str) -> bool:
+    """Set a git config value in the repository.
+
+    Args:
+        repo_dir: Repository directory path
+        key: Git config key
+        value: Value to set
+
+    Returns:
+        True if successful, False otherwise
+    """
+    try:
+        subprocess.run(
+            ["git", "config", key, value],
+            cwd=repo_dir,
+            check=True,
+            capture_output=True,
+        )
+        return True
+    except Exception as e:
+        logger.debug(f"Could not set git config {key}={value}: {e}")
+        return False
+
+
+def configure_git_identity(
+    repo_dir: Path,
+    mode: str = GitConfigMode.USER_INHERIT,
+    *,
+    bot_name: str = "markdown-table-fixer",
+    bot_email: str = "noreply@linuxfoundation.org",
+) -> dict[str, str]:
+    """Configure git identity and signing settings in a repository.
+
+    Args:
+        repo_dir: Repository directory path
+        mode: Configuration mode (USER_INHERIT, USER_NO_SIGN, or BOT_IDENTITY)
+        bot_name: Bot name for BOT_IDENTITY mode
+        bot_email: Bot email for BOT_IDENTITY mode
+
+    Returns:
+        Dict with applied configuration details
+
+    Raises:
+        ValueError: If mode is invalid
+    """
+    valid_modes = [m.value for m in GitConfigMode]
+    if mode not in valid_modes:
+        msg = f"Invalid mode: {mode}. Must be one of {valid_modes}"
+        raise ValueError(msg)
+
+    applied_config: dict[str, str] = {}
+
+    if mode == GitConfigMode.BOT_IDENTITY:
+        # Use bot identity without signing
+        logger.debug("Configuring git with bot identity (no signing)")
+        if _set_repo_git_config(repo_dir, "user.name", bot_name):
+            applied_config["user.name"] = bot_name
+        else:
+            logger.warning(f"Failed to set user.name to {bot_name}")
+
+        if _set_repo_git_config(repo_dir, "user.email", bot_email):
+            applied_config["user.email"] = bot_email
+        else:
+            logger.warning(f"Failed to set user.email to {bot_email}")
+
+        applied_config["mode"] = "bot_identity"
+        return applied_config
+
+    # For USER_INHERIT and USER_NO_SIGN modes, try to get user's config
+    user_name = _get_global_git_config("user.name")
+    user_email = _get_global_git_config("user.email")
+
+    if not user_name or not user_email:
+        logger.warning(
+            "User git config not found, falling back to bot identity"
+        )
+        if _set_repo_git_config(repo_dir, "user.name", bot_name):
+            applied_config["user.name"] = bot_name
+        else:
+            logger.warning(f"Failed to set user.name to {bot_name}")
+
+        if _set_repo_git_config(repo_dir, "user.email", bot_email):
+            applied_config["user.email"] = bot_email
+        else:
+            logger.warning(f"Failed to set user.email to {bot_email}")
+
+        applied_config["mode"] = "bot_identity_fallback"
+        return applied_config
+
+    # Set user identity
+    if _set_repo_git_config(repo_dir, "user.name", user_name):
+        applied_config["user.name"] = user_name
+    else:
+        logger.warning(f"Failed to set user.name to {user_name}")
+
+    if _set_repo_git_config(repo_dir, "user.email", user_email):
+        applied_config["user.email"] = user_email
+    else:
+        logger.warning(f"Failed to set user.email to {user_email}")
+
+    if mode == GitConfigMode.USER_NO_SIGN:
+        # Explicitly disable signing
+        logger.debug("Configuring git with user identity (signing disabled)")
+        if _set_repo_git_config(repo_dir, "commit.gpgsign", "false"):
+            applied_config["commit.gpgsign"] = "false"
+        else:
+            logger.warning("Failed to set commit.gpgsign to false")
+
+        applied_config["mode"] = "user_no_sign"
+        return applied_config
+
+    # USER_INHERIT mode: copy signing configuration
+    logger.debug("Configuring git with user identity (inheriting signing)")
+
+    # Check if user has signing enabled
+    gpgsign = _get_global_git_config("commit.gpgsign")
+    if gpgsign == "true":
+        if _set_repo_git_config(repo_dir, "commit.gpgsign", "true"):
+            applied_config["commit.gpgsign"] = "true"
+        else:
+            logger.warning("Failed to set commit.gpgsign to true")
+
+        # Get GPG format (ssh, openpgp, x509) - default to openpgp if not set
+        gpg_format = _get_global_git_config("gpg.format") or "openpgp"
+        if _set_repo_git_config(repo_dir, "gpg.format", gpg_format):
+            applied_config["gpg.format"] = gpg_format
+        else:
+            logger.warning(f"Failed to set gpg.format to {gpg_format}")
+
+        # Handle SSH-specific configuration
+        if gpg_format == "ssh":
+            # Copy SSH signing key
+            ssh_key = _get_global_git_config("user.signingkey")
+            if ssh_key:
+                if _set_repo_git_config(repo_dir, "user.signingkey", ssh_key):
+                    applied_config["user.signingkey"] = ssh_key
+                else:
+                    logger.warning(
+                        f"Failed to set user.signingkey to {ssh_key}"
+                    )
+
+            # Copy allowed signers file
+            allowed_signers = _get_global_git_config(
+                "gpg.ssh.allowedSignersFile"
+            )
+            if allowed_signers:
+                if _set_repo_git_config(
+                    repo_dir, "gpg.ssh.allowedSignersFile", allowed_signers
+                ):
+                    applied_config["gpg.ssh.allowedSignersFile"] = (
+                        allowed_signers
+                    )
+                else:
+                    logger.warning(
+                        f"Failed to set gpg.ssh.allowedSignersFile to {allowed_signers}"
+                    )
+
+            # Copy default key ID if set
+            default_key = _get_global_git_config("gpg.ssh.defaultKeyCommand")
+            if default_key:
+                if _set_repo_git_config(
+                    repo_dir, "gpg.ssh.defaultKeyCommand", default_key
+                ):
+                    applied_config["gpg.ssh.defaultKeyCommand"] = default_key
+                else:
+                    logger.warning(
+                        f"Failed to set gpg.ssh.defaultKeyCommand to {default_key}"
+                    )
+
+        # Handle GPG-specific configuration (openpgp, x509)
+        elif gpg_format in ["openpgp", "x509"]:
+            # Copy GPG signing key
+            signing_key = _get_global_git_config("user.signingkey")
+            if signing_key:
+                if _set_repo_git_config(
+                    repo_dir, "user.signingkey", signing_key
+                ):
+                    applied_config["user.signingkey"] = signing_key
+                else:
+                    logger.warning(
+                        f"Failed to set user.signingkey to {signing_key}"
+                    )
+
+            # Copy GPG program if specified
+            gpg_program = _get_global_git_config("gpg.program")
+            if gpg_program:
+                if _set_repo_git_config(repo_dir, "gpg.program", gpg_program):
+                    applied_config["gpg.program"] = gpg_program
+                else:
+                    logger.warning(
+                        f"Failed to set gpg.program to {gpg_program}"
+                    )
+
+        logger.info(
+            f"Git signing enabled: format={gpg_format}, "
+            f"key={'configured' if applied_config.get('user.signingkey') else 'default'}"
+        )
+    else:
+        logger.debug("User does not have commit signing enabled")
+
+    applied_config["mode"] = "user_inherit"
+    return applied_config
+
+
+def get_signing_info(repo_dir: Path) -> dict[str, str | bool]:
+    """Get current signing configuration from a repository.
+
+    Args:
+        repo_dir: Repository directory path
+
+    Returns:
+        Dict with signing configuration details
+    """
+    info: dict[str, str | bool] = {}
+
+    try:
+        result = subprocess.run(
+            ["git", "config", "commit.gpgsign"],
+            cwd=repo_dir,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        info["signing_enabled"] = result.stdout.strip() == "true"
+
+        if info["signing_enabled"]:
+            # Get format
+            result = subprocess.run(
+                ["git", "config", "gpg.format"],
+                cwd=repo_dir,
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            gpg_format = result.stdout.strip()
+            info["format"] = gpg_format if gpg_format else "openpgp"
+
+            # Get signing key
+            result = subprocess.run(
+                ["git", "config", "user.signingkey"],
+                cwd=repo_dir,
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            signing_key = result.stdout.strip()
+            if signing_key:
+                info["signing_key"] = signing_key
+
+    except Exception as e:
+        logger.debug(f"Could not get signing info: {e}")
+
+    return info

{markdown_table_fixer-0.1.0 → markdown_table_fixer-0.1.2}/src/markdown_table_fixer/github_client.py

@@ -40,7 +40,7 @@ class GitHubClient:
         """Async context manager exit."""
         pass
 
-    @retry(  # type: ignore[misc]
+    @retry(
         stop=stop_after_attempt(3),
         wait=wait_exponential(multiplier=1, min=2, max=10),
     )
@@ -83,7 +83,7 @@ class GitHubClient:
                 msg = f"Request failed: {e}"
                 raise FileAccessError(msg) from e
 
-    @retry(  # type: ignore[misc]
+    @retry(
         stop=stop_after_attempt(3),
         wait=wait_exponential(multiplier=1, min=2, max=10),
     )

{markdown_table_fixer-0.1.0 → markdown_table_fixer-0.1.2}/src/markdown_table_fixer/pr_fixer.py

@@ -16,6 +16,7 @@ from typing import TYPE_CHECKING, Any
 if TYPE_CHECKING:
     from .github_client import GitHubClient
 
+from .git_config import GitConfigMode, configure_git_identity
 from .models import GitHubFixResult, PRInfo
 from .table_fixer import FileFixer, TableFixer
 from .table_parser import MarkdownFileScanner, TableParser
@@ -25,13 +26,19 @@ from .table_validator import TableValidator
 class PRFixer:
     """Fix markdown tables in pull requests."""
 
-    def __init__(self, client: GitHubClient):
+    def __init__(
+        self,
+        client: GitHubClient,
+        git_config_mode: str = GitConfigMode.USER_INHERIT,
+    ):
         """Initialize PR fixer.
 
         Args:
             client: GitHub API client
+            git_config_mode: Git configuration mode (USER_INHERIT, USER_NO_SIGN, or BOT_IDENTITY)
         """
         self.client = client
+        self.git_config_mode = git_config_mode
         self.logger = logging.getLogger("markdown_table_fixer.pr_fixer")
 
     def _sanitize_message(self, message: str) -> str:
@@ -58,25 +65,114 @@ class PRFixer:
 
         return sanitized
 
-    async def fix_pr_by_url(
+    def _create_error_pr_info(self, pr_url: str) -> PRInfo:
+        """Create a dummy PRInfo for error responses.
+
+        Args:
+            pr_url: PR URL for error messages
+
+        Returns:
+            PRInfo with dummy values for error cases
+        """
+        return PRInfo(
+            number=0,
+            title="",
+            repository="",
+            url=pr_url,
+            author="",
+            is_draft=False,
+            head_ref="",
+            head_sha="",
+            base_ref="",
+            mergeable="",
+            merge_state_status="",
+        )
+
+    def _validate_parameters(
+        self,
+        pr_url: str,
+        update_method: str,
+        sync_strategy: str,
+        conflict_strategy: str,
+    ) -> GitHubFixResult | None:
+        """Validate input parameters.
+
+        Args:
+            pr_url: PR URL for error messages
+            update_method: Update method (already normalized)
+            sync_strategy: Sync strategy (already normalized)
+            conflict_strategy: Conflict strategy (already normalized)
+
+        Returns:
+            GitHubFixResult with error if validation fails, None if valid
+        """
+        # Validate update_method
+        if update_method not in ["git", "api"]:
+            return GitHubFixResult(
+                pr_info=self._create_error_pr_info(pr_url),
+                success=False,
+                message=f"Invalid update_method '{update_method}'. Use 'git' or 'api'",
+            )
+
+        # Validate sync_strategy (only relevant for git method)
+        if update_method == "git" and sync_strategy not in [
+            "none",
+            "rebase",
+            "merge",
+        ]:
+            return GitHubFixResult(
+                pr_info=self._create_error_pr_info(pr_url),
+                success=False,
+                message=f"Invalid sync_strategy '{sync_strategy}'. Use 'none', 'rebase', or 'merge'",
+            )
+
+        # Validate conflict_strategy (only relevant for git method)
+        if update_method == "git" and conflict_strategy not in [
+            "fail",
+            "ours",
+            "theirs",
+        ]:
+            return GitHubFixResult(
+                pr_info=self._create_error_pr_info(pr_url),
+                success=False,
+                message=f"Invalid conflict_strategy '{conflict_strategy}'. Use 'fail', 'ours', or 'theirs'",
+            )
+
+        return None
+
+    async def fix_pr_by_url(  # noqa: PLR0911
         self,
         pr_url: str,
         *,
         sync_strategy: str = "none",
         conflict_strategy: str = "fail",
         dry_run: bool = False,
+        update_method: str = "api",
     ) -> GitHubFixResult:
-        """Fix markdown tables in a PR by URL, amending the existing commit.
+        """Fix markdown tables in a PR by URL.
 
         Args:
             pr_url: GitHub PR URL (e.g., https://github.com/owner/repo/pull/123)
-            sync_strategy: How to sync with base branch: 'none', 'rebase', or 'merge'
-            conflict_strategy: How to resolve conflicts: 'fail', 'ours', or 'theirs'
+            sync_strategy: How to sync with base branch: 'none', 'rebase', or 'merge' (git method only)
+            conflict_strategy: How to resolve conflicts: 'fail', 'ours', or 'theirs' (git method only)
             dry_run: If True, don't actually push changes
+            update_method: Method to apply fixes: 'git' (clone, amend, push) or 'api' (GitHub API commits)
 
         Returns:
             GitHubFixResult with operation details
         """
+        # Normalize parameters to lowercase for case-insensitive comparison
+        update_method = update_method.lower()
+        sync_strategy = sync_strategy.lower()
+        conflict_strategy = conflict_strategy.lower()
+
+        # Validate parameters
+        validation_error = self._validate_parameters(
+            pr_url, update_method, sync_strategy, conflict_strategy
+        )
+        if validation_error:
+            return validation_error
+
         # Parse PR URL
         match = re.match(
             r"https?://github\.com/([^/]+)/([^/]+)/pull/(\d+)", pr_url
@@ -150,23 +246,34 @@ class PRFixer:
                 merge_state_status=pr_data.get("mergeable_state", "unknown"),
             )
 
-            if not clone_url:
+            if not clone_url and update_method == "git":
                 return GitHubFixResult(
                     pr_info=pr_info,
                     success=False,
                     message="PR head repository not accessible",
                 )
 
-            # Clone and fix using Git operations
-            return await self._fix_pr_with_git(
-                pr_info,
-                clone_url,
-                owner,
-                repo,
-                sync_strategy=sync_strategy,
-                conflict_strategy=conflict_strategy,
-                dry_run=dry_run,
-            )
+            # Route to appropriate update method
+            if update_method == "api":
+                # Use GitHub API to update files
+                return await self._fix_pr_with_api(
+                    pr_info,
+                    owner,
+                    repo,
+                    pr_data,
+                    dry_run=dry_run,
+                )
+            else:
+                # Clone and fix using Git operations
+                return await self._fix_pr_with_git(
+                    pr_info,
+                    clone_url,
+                    owner,
+                    repo,
+                    sync_strategy=sync_strategy,
+                    conflict_strategy=conflict_strategy,
+                    dry_run=dry_run,
+                )
 
         except Exception as e:
             self.logger.error(f"Error fixing PR: {e}", exc_info=True)
@@ -199,6 +306,7 @@ class PRFixer:
         sync_strategy: str = "none",
         conflict_strategy: str = "fail",
         dry_run: bool = False,
+        git_config_mode: str | None = None,
     ) -> GitHubFixResult:
         """Fix PR using Git operations (clone, fix, amend, push).
 
@@ -210,10 +318,13 @@ class PRFixer:
             sync_strategy: How to sync with base branch: 'none', 'rebase', or 'merge'
             conflict_strategy: How to resolve conflicts: 'fail', 'ours', or 'theirs'
             dry_run: If True, don't push changes
+            git_config_mode: Override git config mode for this operation
 
         Returns:
             GitHubFixResult with operation details
         """
+        # Use provided mode or fall back to instance default
+        config_mode = git_config_mode or self.git_config_mode
         with tempfile.TemporaryDirectory() as tmpdir:
             repo_dir = Path(tmpdir) / "repo"
             self.logger.debug(f"Cloning {clone_url} to {repo_dir}")
@@ -318,24 +429,14 @@ class PRFixer:
                         files_modified=result_files,
                     )
 
-                # Configure git
-                subprocess.run(
-                    ["git", "config", "user.name", "markdown-table-fixer"],
-                    cwd=repo_dir,
-                    check=True,
-                    capture_output=True,
-                )
-                subprocess.run(
-                    [
-                        "git",
-                        "config",
-                        "user.email",
-                        "noreply@linuxfoundation.org",
-                    ],
-                    cwd=repo_dir,
-                    check=True,
-                    capture_output=True,
+                # Configure git identity and signing
+                git_config = configure_git_identity(
+                    repo_dir,
+                    mode=config_mode,
+                    bot_name="markdown-table-fixer",
+                    bot_email="noreply@linuxfoundation.org",
                 )
+                self.logger.debug(f"Git config applied: {git_config}")
 
                 # Stage the changes
                 for file_path in files_modified:
@@ -575,6 +676,55 @@ class PRFixer:
                         f"Merge had conflicts, attempting to resolve with strategy '{conflict_strategy}'"
                     )
 
+    async def _fix_pr_with_api(
+        self,
+        pr_info: PRInfo,
+        owner: str,
+        repo: str,
+        pr_data: dict[str, Any],
+        *,
+        dry_run: bool = False,
+    ) -> GitHubFixResult:
+        """Fix PR using GitHub API (creates new commits, shows as verified by GitHub).
+
+        Args:
+            pr_info: PR information
+            owner: Repository owner
+            repo: Repository name
+            pr_data: Full PR data from API
+            dry_run: If True, don't actually push changes
+
+        Returns:
+            GitHubFixResult with operation details
+        """
+        result = await self.fix_pr_tables(
+            owner,
+            repo,
+            pr_data,
+            dry_run=dry_run,
+            create_comment=True,
+        )
+
+        if result.get("success"):
+            files_modified = [
+                Path(f["filename"]) for f in result.get("fixed_files", [])
+            ]
+            message = f"Fixed {result.get('tables_fixed', 0)} table(s) in {result.get('files_fixed', 0)} file(s)"
+
+            return GitHubFixResult(
+                pr_info=pr_info,
+                success=True,
+                message=message,
+                files_modified=files_modified,
+            )
+        else:
+            return GitHubFixResult(
+                pr_info=pr_info,
+                success=False,
+                message=result.get("error", "Failed to fix tables via API"),
+                error=result.get("error"),
+            )
+
     async def fix_pr_tables(
         self,
         owner: str,