ai-cr 1.0.1__py3-none-any.whl → 2.0.0.dev2__py3-none-any.whl

ai_cr-2.0.0.dev2.dist-info/METADATA

@@ -0,0 +1,207 @@
+Metadata-Version: 2.3
+Name: ai-cr
+Version: 2.0.0.dev2
+Summary: AI code review tool that works with any language model provider. It detects issues in GitHub pull requests or local changes—instantly, reliably, and without vendor lock-in.
+License: MIT
+Keywords: static code analysis,code review,code quality,ai,coding,assistant,llm,github,automation,devops,developer tools,github actions,workflows,git
+Author: Nayjest
+Author-email: mail@vitaliy.in
+Requires-Python: >=3.11,<4.0
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Requires-Dist: GitPython (>=3.1.44,<4.0.0)
+Requires-Dist: ai-microcore (==4.0.0)
+Requires-Dist: anthropic (>=0.52.2,<0.53.0)
+Requires-Dist: ghapi (>=1.0.6,<1.1.0)
+Requires-Dist: google-generativeai (>=0.8.5,<0.9.0)
+Requires-Dist: jira (>=3.8.0,<4.0.0)
+Requires-Dist: typer (>=0.16.0,<0.17.0)
+Requires-Dist: unidiff (>=0.7.5,<0.8.0)
+Project-URL: Homepage, https://github.com/Nayjest/Gito
+Project-URL: Repository, https://github.com/Nayjest/Gito
+Description-Content-Type: text/markdown
+
+<h1 align="center"><a href="#"><img alt="Gito: AI Code Reviewer" src="press-kit/logo/gito-ai-code-reviewer_logo-180.png" align="center" width="180"></a></h1>
+<p align="center">
+<a href="https://pypi.org/project/gito.bot/" target="_blank"><img src="https://img.shields.io/pypi/v/gito.bot" alt="PYPI Release"></a>
+<a href="https://github.com/Nayjest/Gito/actions/workflows/code-style.yml" target="_blank"><img src="https://github.com/Nayjest/Gito/actions/workflows/code-style.yml/badge.svg" alt="PyLint"></a>
+<a href="https://github.com/Nayjest/Gito/actions/workflows/tests.yml" target="_blank"><img src="https://github.com/Nayjest/Gito/actions/workflows/tests.yml/badge.svg" alt="Tests"></a>
+<img src="https://github.com/Nayjest/Gito/blob/main/coverage.svg" alt="Code Coverage">
+<a href="https://github.com/Nayjest/Gito/blob/main/LICENSE" target="_blank"><img src="https://img.shields.io/static/v1?label=license&message=MIT&color=d08aff" alt="License"></a>
+</p>
+
+**Gito** is an open-source **AI code reviewer** that works with any language model provider.
+It detects issues in GitHub pull requests or local changes—instantly, reliably, and without vendor lock-in.
+
+Get consistent, thorough code reviews in seconds—no waiting for human availability.
+
+## ✨ Why Gito?
+
+- [⚡] **Lightning Fast:** Get detailed code reviews in seconds, not days — powered by parallelized LLM processing  
+- [🔧] **Vendor Agnostic:** Works with any language model provider (OpenAI, Anthropic, Google, local models, etc.)  
+- [🌐] **Universal:** Supports all major programming languages and frameworks  
+- [🔍] **Comprehensive Analysis:** Detect issues across security, performance, maintainability, best practices, and much more  
+- [📈] **Consistent Quality:** Never tired, never biased—consistent review quality every time  
+- [🚀] **Easy Integration:** Automatically reviews pull requests via GitHub Actions and posts results as PR comments  
+- [🎛️] **Infinitely Flexible:** Adapt to any project's standards—configure review rules, severity levels, and focus areas, build custom workflows 
+
+## 🎯 Perfect For
+
+- Solo developers who want expert-level code review without the wait
+- Teams looking to catch issues before human review
+- Open source projects maintaining high code quality at scale
+- CI/CD pipelines requiring automated quality gates
+
+✨ See [code review in action](https://github.com/Nayjest/Gito/pull/39#issuecomment-2906968729) ✨
+
+## 🚀 Quickstart
+
+### 1. Review Pull Requests via GitHub Actions
+
+Create a `.github/workflows/gito-code-review.yml` file:
+
+```yaml
+name: "Gito: AI Code Review"
+on: { pull_request: { types: [opened, synchronize, reopened] } }
+jobs:
+  review:
+    runs-on: ubuntu-latest
+    permissions: { contents: read, pull-requests: write } # 'write' for leaving the summary comment
+    steps:
+    - uses: actions/checkout@v4
+      with: { fetch-depth: 0 }
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with: { python-version: "3.13" }
+    - name: Install AI Code Review tool
+      run: pip install gito.bot~=2.0
+    - name: Run AI code analysis
+      env:
+        LLM_API_KEY: ${{ secrets.LLM_API_KEY }}
+        LLM_API_TYPE: openai
+        MODEL: "gpt-4.1"
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      run: |
+        gito --verbose review
+        gito github-comment --token ${{ secrets.GITHUB_TOKEN }}
+    - uses: actions/upload-artifact@v4
+      with:
+        name: ai-code-review-results
+        path: |
+          code-review-report.md
+          code-review-report.json
+```
+
+> ⚠️ Make sure to add `LLM_API_KEY` to your repository’s GitHub secrets.
+
+💪 Done!  
+PRs to your repository will now receive AI code reviews automatically. ✨  
+See [GitHub Setup Guide](https://github.com/Nayjest/Gito/blob/main/documentation/github_setup.md) for more details.
+
+### 2. Running Code Analysis Locally
+
+#### Initial Local Setup
+
+**Prerequisites:** [Python](https://www.python.org/downloads/) 3.11 / 3.12 / 3.13  
+
+**Step1:** Install [gito.bot](https://github.com/Nayjest/Gito) using [pip](https://en.wikipedia.org/wiki/Pip_(package_manager)).
+```bash
+pip install gito.bot
+```
+
+> **Troubleshooting:**  
+> pip may be also available via cli as `pip3` depending on your Python installation.
+
+**Step2:** Perform initial setup
+
+The following command will perform one-time setup using an interactive wizard.
+You will be prompted to enter LLM configuration details (API type, API key, etc).
+Configuration will be saved to `~/.gito/.env`.
+
+```bash
+gito setup
+```
+
+> **Troubleshooting:**  
+> On some systems, `gito` command may not became available immediately after installation.  
+> Try restarting your terminal or running `python -m gito` instead.
+
+
+#### Perform your first AI code review locally
+
+**Step1:** Navigate to your repository root directory.  
+**Step2:** Switch to the branch you want to review.  
+**Step3:** Run following command
+```bash
+gito review
+```
+
+> **Note:** This will analyze the current branch against the repository main branch by default.  
+> Files that are not staged for commit will be ignored.  
+> See `gito --help` for more options.
+
+**Reviewing remote repository**
+
+```bash
+gito remote git@github.com:owner/repo.git <FEATURE_BRANCH>..<MAIN_BRANCH>
+```
+Use interactive help for details:
+```bash
+gito remote --help
+```
+
+## 🔧 Configuration
+
+Change behavior via `.gito/config.toml`:
+
+- Prompt templates, filtering and post-processing using Python code snippets
+- Tagging, severity, and confidence settings
+- Custom AI awards for developer brilliance
+- Output customization
+
+You can override the default config by placing `.gito/config.toml` in your repo root.
+
+
+See default configuration [here](https://github.com/Nayjest/Gito/blob/main/gito/config.toml).
+
+More details can be found in [📖 Configuration Cookbook](https://github.com/Nayjest/Gito/blob/main/documentation/config_cookbook.md)
+
+## 💻 Development Setup
+
+Install dependencies:
+
+```bash
+make install
+```
+
+Format code and check style:
+
+```bash
+make black
+make cs
+```
+
+Run tests:
+
+```bash
+pytest
+```
+
+## 🤝 Contributing
+
+**Looking for a specific feature or having trouble?**  
+Contributions are welcome! ❤️  
+See [CONTRIBUTING.md](https://github.com/Nayjest/Gito/blob/main/CONTRIBUTING.md) for details.
+
+## 📝 License
+
+Licensed under the [MIT License](https://github.com/Nayjest/Gito/blob/main/LICENSE).
+
+© 2025 [Vitalii Stepanenko](mailto:mail@vitaliy.in)
+

ai_cr-2.0.0.dev2.dist-info/RECORD

@@ -0,0 +1,23 @@
+gito/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gito/__main__.py,sha256=EClCwCzb6h6YBpt0hrnG4h0mlNhNePyg_xBNNSVm1os,65
+gito/bootstrap.py,sha256=ETKioiDc2Npc7znd8HJxA5-twd7sZMPCufIGwXFQSbY,2403
+gito/cli.py,sha256=98Cym9Oil1y1X4SB8cb7xAcJENJPv9ZBPxBEcniB1q4,7994
+gito/commands/__init__.py,sha256=NKUUDskR6taZGbHk5qR9msDS22aHpdzAZlUDxzRdMYA,56
+gito/commands/fix.py,sha256=Nht_14as5txOBGgzrD_1p9pKDJ5J8ghvmaUEVJsJyqI,5462
+gito/commands/gh_comment.py,sha256=uU3CdqsduD_yRfm5eSBC-nE4naofppTkd5inSE0_O_Q,5188
+gito/commands/repl.py,sha256=waN7FJBl98gWmDwZWMa8x157iWbPHIDPJEKmTdzWQ70,396
+gito/config.toml,sha256=NU_nFJtDZVz6dLsz3y33FPiDtf7WP9ZEnzN3mSlxi0s,16002
+gito/constants.py,sha256=DNqh3hOxeLM_KscUH4uFdAc9295o1hiXtwoEw2KxLiU,392
+gito/core.py,sha256=XzrgkNu1GZsjQLkK_PRzV5x-qgdMbhTpSIVrYVadJxc,8300
+gito/issue_trackers.py,sha256=1S8yMuKM6Vq7l81nElNS6IOwXTjEcC5123cp2-6aHkc,453
+gito/pipeline.py,sha256=zI8iRsb8Y18EO6lrUnPFwxBhefJc_VUDVAfcgA9zCWo,2334
+gito/pipeline_steps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gito/pipeline_steps/jira.py,sha256=hujeWGFAbIHPOidPWgvWPYlgB2hjdXHqU5-lo2Qcjvs,2672
+gito/project_config.py,sha256=LCYMcxXYbiijOMwsDwr4FY_E4pDHwUE7UkRzJkgX1Uk,2568
+gito/report_struct.py,sha256=xX93WJSAzVP5_w4fFXjeuDXEOGPvTsEEvLqcOPfWPXM,4234
+gito/utils.py,sha256=BXy7wT7S9CNymPyNlgFqH8WXNTfErKQ6WQlM-IfqYGg,6489
+ai_cr-2.0.0.dev2.dist-info/entry_points.txt,sha256=Ua1DxkhJJ8TZuLgnH-IlWCkrre_0S0dq_GtYRaYupWk,38
+ai_cr-2.0.0.dev2.dist-info/LICENSE,sha256=XATf3zv-CppUSJqI18KLhwnPEomUXEl5WbBzFyb9OSU,1096
+ai_cr-2.0.0.dev2.dist-info/METADATA,sha256=TRMBhhnhRBWsMGbHZsyfXG0-VFchXmmw_HwTjd8YnHk,7763
+ai_cr-2.0.0.dev2.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+ai_cr-2.0.0.dev2.dist-info/RECORD,,

ai_cr-2.0.0.dev2.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+gito=gito.cli:main
+

{ai_code_review → gito}/bootstrap.py

@@ -3,9 +3,10 @@ import os
 from datetime import datetime
 
 import microcore as mc
-from ai_code_review.utils import is_running_in_github_action
+import typer
 
-from .constants import ENV_CONFIG_FILE
+from .utils import is_running_in_github_action
+from .constants import HOME_ENV_PATH, EXECUTABLE
 
 
 def setup_logging():
@@ -32,7 +33,7 @@ def bootstrap():
     logging.info("Bootstrapping...")
     try:
         mc.configure(
-            DOT_ENV_FILE=ENV_CONFIG_FILE,
+            DOT_ENV_FILE=HOME_ENV_PATH,
             USE_LOGGING=True,
             EMBEDDING_DB_TYPE=mc.EmbeddingDbType.NONE,
         )
@@ -51,7 +52,7 @@ def bootstrap():
             )
         else:
             msg += (
-                "\nPlease run 'ai-code-review setup' "
+                f"\nPlease run '{EXECUTABLE} setup' "
                 "to configure LLM API access (API keys, model, etc)."
             )
         print(mc.ui.red(msg))
@@ -60,3 +61,6 @@ def bootstrap():
         logging.error(f"Unexpected configuration error: {e}")
         raise SystemExit(3)
     mc.logging.LoggingConfig.STRIP_REQUEST_LINES = [300, 15]
+
+
+app = typer.Typer(pretty_exceptions_show_locals=False)

{ai_code_review → gito}/cli.py

@@ -12,18 +12,25 @@ from git import Repo
 
 from .core import review, get_diff, filter_diff
 from .report_struct import Report
-from .constants import ENV_CONFIG_FILE
-from .bootstrap import bootstrap
+from .constants import HOME_ENV_PATH
+from .bootstrap import bootstrap, app
 from .project_config import ProjectConfig
 from .utils import no_subcommand, parse_refs_pair
 
-app = typer.Typer(pretty_exceptions_show_locals=False)
+# Import fix command to register it
+from .commands import fix, gh_comment  # noqa
+
+
 app_no_subcommand = typer.Typer(pretty_exceptions_show_locals=False)
 
 
 def main():
     if sys.platform == "win32":
         asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+    # Help subcommand alias: if 'help' appears as first non-option arg, replace it with '--help'
+    if len(sys.argv) > 1 and sys.argv[1] == "help":
+        sys.argv = [sys.argv[0]] + sys.argv[2:] + ["--help"]
+
     if no_subcommand(app):
         bootstrap()
         app_no_subcommand()
@@ -33,10 +40,10 @@ def main():
 
 @app.callback(invoke_without_command=True)
 def cli(ctx: typer.Context, verbose: bool = typer.Option(default=False)):
-    if verbose:
-        mc.logging.LoggingConfig.STRIP_REQUEST_LINES = None
     if ctx.invoked_subcommand != "setup":
         bootstrap()
+    if verbose:
+        mc.logging.LoggingConfig.STRIP_REQUEST_LINES = None
 
 
 def args_to_target(refs, what, against) -> tuple[str | None, str | None]:
@@ -97,6 +104,7 @@ def arg_against() -> typer.Option:
 
 @app_no_subcommand.command(name="review", help="Perform code review")
 @app.command(name="review", help="Perform code review")
+@app.command(name="run", hidden=True)
 def cmd_review(
     refs: str = arg_refs(),
     what: str = arg_what(),
@@ -117,12 +125,21 @@ def cmd_review(
 
 @app.command(help="Configure LLM for local usage interactively")
 def setup():
-    mc.interactive_setup(ENV_CONFIG_FILE)
-
-
-@app.command()
-def render(format: str = Report.Format.MARKDOWN):
-    print(Report.load().render(format=format))
+    mc.interactive_setup(HOME_ENV_PATH)
+
+
+@app.command(name="render")
+@app.command(name="report", hidden=True)
+def render(
+    format: str = typer.Argument(default=Report.Format.CLI),
+    source: str = typer.Option(
+        "",
+        "--src",
+        "--source",
+        help="Source file (json) to load the report from"
+    )
+):
+    Report.load(file_name=source).to_cli(report_format=format)
 
 
 @app.command(help="Review remote code")
@@ -225,7 +242,7 @@ def files(
         f"{mc.ui.yellow(_against or repo.remotes.origin.refs.HEAD.reference.name)}"
         f"{' filtered by '+mc.ui.cyan(filters) if filters else ''}"
     )
-
+    repo.close()
     for patch in patch_set:
         if patch.is_added_file:
             color = mc.ui.green

gito/commands/__init__.py

@@ -0,0 +1 @@
+# Command modules register themselves with the CLI app

gito/commands/fix.py

@@ -0,0 +1,157 @@
+"""
+Fix issues from code review report
+"""
+import json
+import logging
+from pathlib import Path
+from typing import Optional
+
+import git
+import typer
+from microcore import ui
+
+from ..bootstrap import app
+from ..constants import JSON_REPORT_FILE_NAME
+from ..report_struct import Report, Issue
+
+
+@app.command(help="Fix an issue from the code review report")
+def fix(
+    issue_number: int = typer.Argument(..., help="Issue number to fix"),
+    report_path: Optional[str] = typer.Option(
+        None,
+        "--report",
+        "-r",
+        help="Path to the code review report (default: code-review-report.json)"
+    ),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", "-d", help="Only print changes without applying them"
+    ),
+    commit: bool = typer.Option(default=False, help="Commit changes after applying them"),
+    push: bool = typer.Option(default=False, help="Push changes to the remote repository"),
+) -> list[str]:
+    """
+    Applies the proposed change for the specified issue number from the code review report.
+    """
+    # Load the report
+    report_path = report_path or JSON_REPORT_FILE_NAME
+    try:
+        report = Report.load(report_path)
+    except (FileNotFoundError, json.JSONDecodeError) as e:
+        logging.error(f"Failed to load report from {report_path}: {e}")
+        raise typer.Exit(code=1)
+
+    # Find the issue by number
+    issue: Optional[Issue] = None
+    for file_issues in report.issues.values():
+        for i in file_issues:
+            if i.id == issue_number:
+                issue = i
+                break
+        if issue:
+            break
+
+    if not issue:
+        logging.error(f"Issue #{issue_number} not found in the report")
+        raise typer.Exit(code=1)
+
+    if not issue.affected_lines:
+        logging.error(f"Issue #{issue_number} has no affected lines specified")
+        raise typer.Exit(code=1)
+
+    if not any(affected_line.proposal for affected_line in issue.affected_lines):
+        logging.error(f"Issue #{issue_number} has no proposal for fixing")
+        raise typer.Exit(code=1)
+
+    # Apply the fix
+    logging.info(f"Fixing issue #{issue_number}: {ui.cyan(issue.title)}")
+
+    for affected_line in issue.affected_lines:
+        if not affected_line.proposal:
+            continue
+
+        file_path = Path(issue.file)
+        if not file_path.exists():
+            logging.error(f"File {file_path} not found")
+            continue
+
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                lines = f.readlines()
+        except Exception as e:
+            logging.error(f"Failed to read file {file_path}: {e}")
+            continue
+
+        # Check if line numbers are valid
+        if affected_line.start_line < 1 or affected_line.end_line > len(lines):
+            logging.error(
+                f"Invalid line range: {affected_line.start_line}-{affected_line.end_line} "
+                f"(file has {len(lines)} lines)"
+            )
+            continue
+
+        # Get the affected line content for display
+        affected_content = "".join(lines[affected_line.start_line - 1:affected_line.end_line])
+        print(f"\nFile: {ui.blue(issue.file)}")
+        print(f"Lines: {affected_line.start_line}-{affected_line.end_line}")
+        print(f"Current content:\n{ui.red(affected_content)}")
+        print(f"Proposed change:\n{ui.green(affected_line.proposal)}")
+
+        if dry_run:
+            print(f"{ui.yellow('Dry run')}: Changes not applied")
+            continue
+
+        # Apply the change
+        proposal_lines = affected_line.proposal.splitlines(keepends=True)
+        if not proposal_lines:
+            proposal_lines = [""]
+        elif not proposal_lines[-1].endswith(("\n", "\r")):
+            # Ensure the last line has a newline if the original does
+            if (
+                affected_line.end_line < len(lines)
+                and lines[affected_line.end_line - 1].endswith(("\n", "\r"))
+            ):
+                proposal_lines[-1] += "\n"
+
+        lines[affected_line.start_line - 1:affected_line.end_line] = proposal_lines
+
+        # Write changes back to the file
+        try:
+            with open(file_path, "w", encoding="utf-8") as f:
+                f.writelines(lines)
+            print(f"{ui.green('Success')}: Changes applied to {file_path}")
+        except Exception as e:
+            logging.error(f"Failed to write changes to {file_path}: {e}")
+            raise typer.Exit(code=1)
+
+    print(f"\n{ui.green('✓')} Issue #{issue_number} fixed successfully")
+
+    changed_files = [file_path.as_posix()]
+    if commit:
+        commit_changes(
+            changed_files,
+            commit_message=f"[AI] Fix issue {issue_number}:{issue.title}",
+            push=push
+        )
+    return changed_files
+
+
+def commit_changes(
+    files: list[str],
+    repo: git.Repo = None,
+    commit_message: str = "fix by AI",
+    push: bool = True
+) -> None:
+    if opened_repo := not repo:
+        repo = git.Repo(".")
+    for i in files:
+        repo.index.add(i)
+    repo.index.commit(commit_message)
+    if push:
+        origin = repo.remotes.origin
+        origin.push()
+        logging.info(f"Changes pushed to {origin.name}")
+    else:
+        logging.info("Changes committed but not pushed to remote")
+    if opened_repo:
+        repo.close()

gito/commands/gh_comment.py

@@ -0,0 +1,157 @@
+"""
+Fix issues from code review report
+"""
+
+import logging
+import os
+import re
+from pathlib import Path
+from typing import Optional
+import zipfile
+
+import requests
+import typer
+from fastcore.basics import AttrDict
+from gito.project_config import ProjectConfig
+from gito.utils import extract_gh_owner_repo
+from microcore import ui
+from ghapi.all import GhApi
+import git
+
+from ..bootstrap import app
+from ..constants import JSON_REPORT_FILE_NAME
+from .fix import fix
+from ..utils import is_running_in_github_action
+
+
+@app.command()
+def react_to_comment(
+    comment_id: int = typer.Argument(),
+    gh_token: str = typer.Option(
+        "",
+        "--gh-token",
+        "--token",
+        "-t",
+        "--github-token",
+        help="GitHub token for authentication",
+    ),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", "-d", help="Only print changes without applying them"
+    ),
+):
+    repo = git.Repo(".")  # Current directory
+    owner, repo_name = extract_gh_owner_repo(repo)
+    logging.info(f"Using repository: {ui.yellow}{owner}/{repo_name}{ui.reset}")
+    gh_token = (
+        gh_token or os.getenv("GITHUB_TOKEN", None) or os.getenv("GH_TOKEN", None)
+    )
+    api = GhApi(owner=owner, repo=repo_name, token=gh_token)
+    comment = api.issues.get_comment(comment_id=comment_id)
+    logging.info(
+        f"Comment by {ui.yellow('@' + comment.user.login)}: "
+        f"{ui.green(comment.body)}\n"
+        f"url: {comment.html_url}"
+    )
+
+    cfg = ProjectConfig.load_for_repo(repo)
+    if not any(
+        trigger.lower() in comment.body.lower() for trigger in cfg.mention_triggers
+    ):
+        ui.error("No mention trigger found in comment, no reaction added.")
+        return
+    if not is_running_in_github_action():
+        # @todo: need service account to react to comments
+        logging.info("Comment contains mention trigger, reacting with 'eyes'.")
+        api.reactions.create_for_issue_comment(comment_id=comment_id, content="eyes")
+
+    pr = int(comment.issue_url.split("/")[-1])
+    print(f"Processing comment for PR #{pr}...")
+    out_folder = "artifact"
+    download_latest_code_review_artifact(
+        api, pr_number=pr, gh_token=gh_token, out_folder=out_folder
+    )
+
+    issue_ids = extract_fix_args(comment.body)
+    if not issue_ids:
+        ui.error("Can't identify target command in the text.")
+        return
+    logging.info(f"Extracted issue IDs: {ui.yellow(str(issue_ids))}")
+
+    fix(
+        issue_ids[0],  # @todo: support multiple IDs
+        report_path=Path(out_folder) / JSON_REPORT_FILE_NAME,
+        dry_run=dry_run,
+        commit=not dry_run,
+        push=not dry_run,
+    )
+    logging.info("Fix applied successfully.")
+
+
+def last_code_review_run(api: GhApi, pr_number: int) -> AttrDict | None:
+    pr = api.pulls.get(pr_number)
+    sha = pr["head"]["sha"]  # noqa
+    branch = pr["head"]["ref"]
+
+    runs = api.actions.list_workflow_runs_for_repo(branch=branch)["workflow_runs"]
+    # Find the run for this SHA
+    run = next(
+        (
+            r
+            for r in runs  # r['head_sha'] == sha and
+            if (
+                any(
+                    marker in r["path"].lower()
+                    for marker in ["code-review", "code_review", "cr"]
+                )
+                or "gito.yml" in r["name"].lower()
+            )
+            and r["status"] == "completed"
+        ),
+        None,
+    )
+    return run
+
+
+def download_latest_code_review_artifact(
+    api: GhApi, pr_number: int, gh_token: str, out_folder: Optional[str] = "artifact"
+) -> tuple[str, dict] | None:
+    run = last_code_review_run(api, pr_number)
+    if not run:
+        raise Exception("No workflow run found for this PR/SHA")
+
+    artifacts = api.actions.list_workflow_run_artifacts(run["id"])["artifacts"]
+    if not artifacts:
+        raise Exception("No artifacts found for this workflow run")
+
+    latest_artifact = artifacts[0]
+    url = latest_artifact["archive_download_url"]
+    print(f"Artifact: {latest_artifact['name']}, Download URL: {url}")
+    headers = {"Authorization": f"token {gh_token}"} if gh_token else {}
+    zip_path = "artifact.zip"
+    try:
+        with requests.get(url, headers=headers, stream=True) as r:
+            r.raise_for_status()
+            with open(zip_path, "wb") as f:
+                for chunk in r.iter_content(chunk_size=8192):
+                    f.write(chunk)
+
+        # Unpack to ./artifact
+        os.makedirs("artifact", exist_ok=True)
+        with zipfile.ZipFile(zip_path, "r") as zip_ref:
+            zip_ref.extractall("artifact")
+    finally:
+        if os.path.exists(zip_path):
+            os.remove(zip_path)
+
+    print("Artifact unpacked to ./artifact")
+
+
+def extract_fix_args(text: str) -> list[int]:
+    pattern1 = r"fix\s+(?:issues?)?(?:\s+)?#?(\d+(?:\s*,\s*#?\d+)*)"
+    match = re.search(pattern1, text)
+    if match:
+        numbers_str = match.group(1)
+        numbers = re.findall(r"\d+", numbers_str)
+        issue_numbers = [int(num) for num in numbers]
+        return issue_numbers
+    return []