ai-cr 2.0.2__tar.gz → 3.0.0__tar.gz

{ai_cr-2.0.2 → ai_cr-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ai-cr
-Version: 2.0.2
+Version: 3.0.0
 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
@@ -16,8 +16,8 @@ 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: ai-microcore (==4.2.1)
+Requires-Dist: anthropic (>=0.57.1,<0.58.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)
@@ -87,7 +87,7 @@ jobs:
       uses: actions/setup-python@v5
       with: { python-version: "3.13" }
     - name: Install AI Code Review tool
-      run: pip install gito.bot~=2.0
+      run: pip install gito.bot~=3.0
     - name: Run AI code analysis
       env:
         LLM_API_KEY: ${{ secrets.LLM_API_KEY }}

{ai_cr-2.0.2 → ai_cr-3.0.0}/README.md

@@ -58,7 +58,7 @@ jobs:
       uses: actions/setup-python@v5
       with: { python-version: "3.13" }
     - name: Install AI Code Review tool
-      run: pip install gito.bot~=2.0
+      run: pip install gito.bot~=3.0
     - name: Run AI code analysis
       env:
         LLM_API_KEY: ${{ secrets.LLM_API_KEY }}

{ai_cr-2.0.2 → ai_cr-3.0.0}/gito/bootstrap.py

@@ -1,15 +1,18 @@
-import logging
 import os
+import sys
+import io
+import logging
 from datetime import datetime
+from pathlib import Path
 
 import microcore as mc
-import typer
 
 from .utils import is_running_in_github_action
-from .constants import HOME_ENV_PATH, EXECUTABLE
+from .constants import HOME_ENV_PATH, EXECUTABLE, PROJECT_GITO_FOLDER
+from .env import Env
 
 
-def setup_logging():
+def setup_logging(log_level: int = logging.INFO):
     class CustomFormatter(logging.Formatter):
         def format(self, record):
             dt = datetime.fromtimestamp(record.created).strftime("%Y-%m-%d %H:%M:%S")
@@ -24,19 +27,41 @@ def setup_logging():
 
     handler = logging.StreamHandler()
     handler.setFormatter(CustomFormatter())
-    logging.basicConfig(level=logging.INFO, handlers=[handler])
+    logging.basicConfig(level=log_level, handlers=[handler])
 
 
-def bootstrap():
+def bootstrap(verbosity: int = 1):
     """Bootstrap the application with the environment configuration."""
-    setup_logging()
-    logging.info("Bootstrapping...")
+    log_levels_by_verbosity = {
+        0: logging.CRITICAL,
+        1: logging.INFO,
+        2: logging.DEBUG,
+        3: logging.DEBUG,
+    }
+    Env.verbosity = verbosity
+    Env.logging_level = log_levels_by_verbosity.get(verbosity, logging.INFO)
+    setup_logging(Env.logging_level)
+    logging.info("Bootstrapping... "+mc.ui.gray(f"[verbosity={verbosity}]"))
+
+    # cp1251 is used on Windows when redirecting output
+    if sys.stdout.encoding and sys.stdout.encoding.lower() != "utf-8":
+        sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+
     try:
         mc.configure(
             DOT_ENV_FILE=HOME_ENV_PATH,
-            USE_LOGGING=True,
+            USE_LOGGING=verbosity >= 1,
             EMBEDDING_DB_TYPE=mc.EmbeddingDbType.NONE,
+            PROMPT_TEMPLATES_PATH=[
+                PROJECT_GITO_FOLDER,
+                Path(__file__).parent / "tpl"
+            ],
         )
+        if verbosity > 1:
+            mc.logging.LoggingConfig.STRIP_REQUEST_LINES = None
+        else:
+            mc.logging.LoggingConfig.STRIP_REQUEST_LINES = [300, 15]
+
     except mc.LLMConfigError as e:
         msg = str(e)
         if is_running_in_github_action():
@@ -60,7 +85,3 @@ def bootstrap():
     except Exception as e:
         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_cr-3.0.0/gito/cli.py

@@ -0,0 +1,210 @@
+import os
+import asyncio
+import logging
+import sys
+import textwrap
+
+import microcore as mc
+import typer
+from git import Repo
+
+from .core import review, get_diff, filter_diff, answer
+from .cli_base import (
+    app,
+    args_to_target,
+    arg_refs,
+    arg_what,
+    arg_filters,
+    arg_out,
+    arg_against,
+    get_repo_context,
+)
+from .report_struct import Report
+from .constants import HOME_ENV_PATH, GITHUB_MD_REPORT_FILE_NAME
+from .bootstrap import bootstrap
+from .utils import no_subcommand, extract_gh_owner_repo, remove_html_comments
+from .gh_api import resolve_gh_token
+
+# Import fix command to register it
+from .commands import fix, gh_react_to_comment, repl, deploy  # noqa
+from .commands.gh_post_review_comment import post_github_cr_comment
+from .commands.linear_comment import linear_comment
+
+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()
+    else:
+        app()
+
+
+@app.callback(invoke_without_command=True)
+def cli(
+    ctx: typer.Context,
+    verbose: bool = typer.Option(default=None),
+    verbosity: int = typer.Option(
+        None,
+        '--verbosity', '-v',
+        help="Set verbosity level (0-3, default 1)"
+    ),
+):
+    if verbose is not None and verbosity is not None:
+        raise typer.BadParameter(
+            "Please specify either --verbose or --verbosity, not both."
+        )
+    if verbose is not None:
+        verbosity = 2 if verbose else 0
+    if verbosity is None:
+        verbosity = 1
+
+    if ctx.invoked_subcommand != "setup":
+        bootstrap(verbosity)
+
+
+@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(),
+    against: str = arg_against(),
+    filters: str = arg_filters(),
+    merge_base: bool = typer.Option(default=True, help="Use merge base for comparison"),
+    url: str = typer.Option("", "--url", help="Git repository URL"),
+    post_comment: bool = typer.Option(default=False, help="Post review comment to GitHub"),
+    pr: int = typer.Option(
+        default=None,
+        help=textwrap.dedent("""\n
+        GitHub Pull Request number to post the comment to
+        (for local usage together with --post-comment,
+        in the github actions PR is resolved from the environment)
+        """)
+    ),
+    out: str = arg_out()
+):
+    _what, _against = args_to_target(refs, what, against)
+    with get_repo_context(url, _what) as (repo, out_folder):
+        asyncio.run(review(
+            repo=repo,
+            what=_what,
+            against=_against,
+            filters=filters,
+            use_merge_base=merge_base,
+            out_folder=out or out_folder,
+        ))
+        if post_comment:
+            try:
+                owner, repo_name = extract_gh_owner_repo(repo)
+            except ValueError as e:
+                logging.error(
+                    "Error posting comment:\n"
+                    "Could not extract GitHub owner and repository name from the local repository."
+                )
+                raise typer.Exit(code=1) from e
+            post_github_cr_comment(
+                md_report_file=os.path.join(out or out_folder, GITHUB_MD_REPORT_FILE_NAME),
+                pr=pr,
+                gh_repo=f"{owner}/{repo_name}",
+                token=resolve_gh_token()
+            )
+
+
+@app.command(name="ask", help="Answer questions about codebase changes")
+@app.command(name="answer", hidden=True)
+@app.command(name="talk", hidden=True)
+def cmd_answer(
+    question: str = typer.Argument(help="Question to ask about the codebase changes"),
+    refs: str = arg_refs(),
+    what: str = arg_what(),
+    against: str = arg_against(),
+    filters: str = arg_filters(),
+    merge_base: bool = typer.Option(default=True, help="Use merge base for comparison"),
+    use_pipeline: bool = typer.Option(default=True),
+    post_to: str = typer.Option(
+        help="Post answer to ... Supported values: linear",
+        default=None,
+        show_default=False
+    ),
+):
+    _what, _against = args_to_target(refs, what, against)
+    if str(question).startswith("tpl:"):
+        prompt_file = str(question)[4:]
+        question = ""
+    else:
+        prompt_file = None
+    out = answer(
+        question=question,
+        what=_what,
+        against=_against,
+        filters=filters,
+        use_merge_base=merge_base,
+        prompt_file=prompt_file,
+        use_pipeline=use_pipeline,
+    )
+    if post_to == 'linear':
+        logging.info("Posting answer to Linear...")
+        linear_comment(remove_html_comments(out))
+    return out
+
+
+@app.command(help="Configure LLM for local usage interactively")
+def setup():
+    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="List files in the diff. Might be useful to check what will be reviewed.")
+def files(
+    refs: str = arg_refs(),
+    what: str = arg_what(),
+    against: str = arg_against(),
+    filters: str = arg_filters(),
+    merge_base: bool = typer.Option(default=True, help="Use merge base for comparison"),
+    diff: bool = typer.Option(default=False, help="Show diff content")
+):
+    _what, _against = args_to_target(refs, what, against)
+    repo = Repo(".")
+    try:
+        patch_set = get_diff(repo=repo, what=_what, against=_against, use_merge_base=merge_base)
+        patch_set = filter_diff(patch_set, filters)
+        print(
+            f"Changed files: "
+            f"{mc.ui.green(_what or 'INDEX')} vs "
+            f"{mc.ui.yellow(_against or repo.remotes.origin.refs.HEAD.reference.name)}"
+            f"{' filtered by ' + mc.ui.cyan(filters) if filters else ''}"
+        )
+
+        for patch in patch_set:
+            if patch.is_added_file:
+                color = mc.ui.green
+            elif patch.is_removed_file:
+                color = mc.ui.red
+            else:
+                color = mc.ui.blue
+            print(f"- {color(patch.path)}")
+            if diff:
+                print(mc.ui.gray(textwrap.indent(str(patch), "  ")))
+    finally:
+        repo.close()

ai_cr-3.0.0/gito/cli_base.py

@@ -0,0 +1,90 @@
+import contextlib
+import logging
+import tempfile
+
+import microcore as mc
+import typer
+from git import Repo
+from gito.utils import parse_refs_pair
+
+
+def args_to_target(refs, what, against) -> tuple[str | None, str | None]:
+    _what, _against = parse_refs_pair(refs)
+    if _what:
+        if what:
+            raise typer.BadParameter(
+                "You cannot specify both 'refs' <WHAT>..<AGAINST> and '--what'. Use one of them."
+            )
+    else:
+        _what = what
+    if _against:
+        if against:
+            raise typer.BadParameter(
+                "You cannot specify both 'refs' <WHAT>..<AGAINST> and '--against'. Use one of them."
+            )
+    else:
+        _against = against
+    return _what, _against
+
+
+def arg_refs() -> typer.Argument:
+    return typer.Argument(
+        default=None,
+        help="Git refs to review, [what]..[against] e.g. 'HEAD..HEAD~1'"
+    )
+
+
+def arg_what() -> typer.Option:
+    return typer.Option(None, "--what", "-w", help="Git ref to review")
+
+
+def arg_filters() -> typer.Option:
+    return typer.Option(
+        "", "--filter", "-f", "--filters",
+        help="""
+            filter reviewed files by glob / fnmatch pattern(s),
+            e.g. 'src/**/*.py', may be comma-separated
+            """,
+    )
+
+
+def arg_out() -> typer.Option:
+    return typer.Option(
+        None,
+        "--out", "-o", "--output",
+        help="Output folder for the code review report"
+    )
+
+
+def arg_against() -> typer.Option:
+    return typer.Option(
+        None,
+        "--against", "-vs", "--vs",
+        help="Git ref to compare against"
+    )
+
+
+app = typer.Typer(pretty_exceptions_show_locals=False)
+
+
+@contextlib.contextmanager
+def get_repo_context(url: str, branch: str):
+    """Context manager for handling both local and remote repositories."""
+    if url:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            logging.info(
+                f"get_repo_context: "
+                f"Cloning [{mc.ui.green(url)}] to {mc.utils.file_link(temp_dir)} ..."
+            )
+            repo = Repo.clone_from(url, branch=branch, to_path=temp_dir)
+            try:
+                yield repo, temp_dir
+            finally:
+                repo.close()
+    else:
+        logging.info("get_repo_context: Using local repo...")
+        repo = Repo(".")
+        try:
+            yield repo, "."
+        finally:
+            repo.close()

ai_cr-3.0.0/gito/commands/deploy.py

@@ -0,0 +1,101 @@
+from pathlib import Path
+
+import microcore as mc
+from microcore import ApiType, ui, utils
+from git import Repo
+
+from ..utils import version, extract_gh_owner_repo
+from ..cli_base import app
+
+
+@app.command(name="deploy", help="Deploy Gito workflows to GitHub Actions")
+@app.command(name="init", hidden=True)
+def deploy(api_type: ApiType = None, commit: bool = None, rewrite: bool = False):
+    repo = Repo(".")
+    workflow_files = dict(
+        code_review=Path(".github/workflows/gito-code-review.yml"),
+        react_to_comments=Path(".github/workflows/gito-react-to-comments.yml")
+    )
+    for file in workflow_files.values():
+        if file.exists():
+            message = f"Gito workflow already exists at {utils.file_link(file)}."
+            if rewrite:
+                ui.warning(message)
+            else:
+                message += "\nUse --rewrite to overwrite it."
+                ui.error(message)
+                return False
+
+    api_types = [ApiType.ANTHROPIC, ApiType.OPEN_AI, ApiType.GOOGLE_AI_STUDIO]
+    default_models = {
+        ApiType.ANTHROPIC: "claude-sonnet-4-20250514",
+        ApiType.OPEN_AI: "gpt-4.1",
+        ApiType.GOOGLE_AI_STUDIO: "gemini-2.5-pro",
+    }
+    secret_names = {
+        ApiType.ANTHROPIC: "ANTHROPIC_API_KEY",
+        ApiType.OPEN_AI: "OPENAI_API_KEY",
+        ApiType.GOOGLE_AI_STUDIO: "GOOGLE_AI_API_KEY",
+    }
+    if not api_type:
+        api_type = mc.ui.ask_choose(
+            "Choose your LLM API type",
+            api_types,
+        )
+    elif api_type not in api_types:
+        mc.ui.error(f"Unsupported API type: {api_type}")
+        return False
+    major, minor, *_ = version().split(".")
+    template_vars = dict(
+        model=default_models[api_type],
+        api_type=api_type,
+        secret_name=secret_names[api_type],
+        major=major,
+        minor=minor,
+        ApiType=ApiType,
+        remove_indent=True,
+    )
+    gito_code_review_yml = mc.tpl(
+        "github_workflows/gito-code-review.yml.j2",
+        **template_vars
+    )
+    gito_react_to_comments_yml = mc.tpl(
+        "github_workflows/gito-react-to-comments.yml.j2",
+        **template_vars
+    )
+
+    workflow_files["code_review"].parent.mkdir(parents=True, exist_ok=True)
+    workflow_files["code_review"].write_text(gito_code_review_yml)
+    workflow_files["react_to_comments"].write_text(gito_react_to_comments_yml)
+    print(
+        mc.ui.green("Gito workflows have been created.\n")
+        + f"  - {mc.utils.file_link(workflow_files['code_review'])}\n"
+        + f"  - {mc.utils.file_link(workflow_files['react_to_comments'])}\n"
+    )
+    owner, repo_name = extract_gh_owner_repo(repo)
+    if commit is True or commit is None and mc.ui.ask_yn(
+        "Do you want to commit and push created GitHub workflows to a new branch?"
+    ):
+        repo.git.add([str(file) for file in workflow_files.values()])
+        branch_name = "gito_deploy"
+        if not repo.active_branch.name.startswith(branch_name):
+            repo.git.checkout("-b", branch_name)
+        repo.git.commit("-m", "Deploy Gito workflows")
+        repo.git.push("origin", branch_name)
+        print(f"Changes pushed to {branch_name} branch.")
+        print(
+            f"Please create a PR from {branch_name} to your main branch and merge it:\n"
+            f"https://github.com/{owner}/{repo_name}/compare/gito_deploy?expand=1"
+        )
+    else:
+        print(
+            "Now you can commit and push created GitHub workflows to your main repository branch.\n"
+        )
+
+    print(
+        "(!IMPORTANT):\n"
+        f"Add {mc.ui.cyan(secret_names[api_type])} with actual API_KEY "
+        "to your repository secrets here:\n"
+        f"https://github.com/{owner}/{repo_name}/settings/secrets/actions"
+    )
+    return True

{ai_cr-2.0.2 → ai_cr-3.0.0}/gito/commands/fix.py

@@ -10,7 +10,7 @@ import git
 import typer
 from microcore import ui
 
-from ..bootstrap import app
+from ..cli_base import app
 from ..constants import JSON_REPORT_FILE_NAME
 from ..report_struct import Report, Issue
 

ai_cr-3.0.0/gito/commands/gh_post_review_comment.py

@@ -0,0 +1,111 @@
+import logging
+import os
+from time import sleep
+
+import typer
+from ghapi.core import GhApi
+
+from ..cli_base import app
+from ..constants import GITHUB_MD_REPORT_FILE_NAME, HTML_CR_COMMENT_MARKER
+from ..gh_api import (
+    post_gh_comment,
+    resolve_gh_token,
+    hide_gh_comment,
+)
+from ..project_config import ProjectConfig
+
+
+@app.command(name="github-comment", help="Leave a GitHub PR comment with the review.")
+def post_github_cr_comment(
+    md_report_file: str = typer.Option(default=None),
+    pr: int = typer.Option(default=None),
+    gh_repo: str = typer.Option(default=None, help="owner/repo"),
+    token: str = typer.Option(
+        "", help="GitHub token (or set GITHUB_TOKEN env var)"
+    ),
+):
+    """
+    Leaves a comment with the review on the current GitHub pull request.
+    """
+    file = md_report_file or GITHUB_MD_REPORT_FILE_NAME
+    if not os.path.exists(file):
+        logging.error(f"Review file not found: {file}, comment will not be posted.")
+        raise typer.Exit(4)
+
+    with open(file, "r", encoding="utf-8") as f:
+        body = f.read()
+
+    token = resolve_gh_token(token)
+    if not token:
+        print("GitHub token is required (--token or GITHUB_TOKEN env var).")
+        raise typer.Exit(1)
+    config = ProjectConfig.load()
+    gh_env = config.prompt_vars["github_env"]
+    gh_repo = gh_repo or gh_env.get("github_repo", "")
+    pr_env_val = gh_env.get("github_pr_number", "")
+    logging.info(f"github_pr_number = {pr_env_val}")
+
+    if not pr:
+        # e.g. could be "refs/pull/123/merge" or a direct number
+        if "/" in pr_env_val and "pull" in pr_env_val:
+            # refs/pull/123/merge
+            try:
+                pr_num_candidate = pr_env_val.strip("/").split("/")
+                idx = pr_num_candidate.index("pull")
+                pr = int(pr_num_candidate[idx + 1])
+            except Exception:
+                pass
+        else:
+            try:
+                pr = int(pr_env_val)
+            except ValueError:
+                pass
+    if not pr:
+        if pr_str := os.getenv("PR_NUMBER_FROM_WORKFLOW_DISPATCH"):
+            try:
+                pr = int(pr_str)
+            except ValueError:
+                pass
+    if not pr:
+        logging.error("Could not resolve PR number from environment variables.")
+        raise typer.Exit(3)
+
+    if not post_gh_comment(gh_repo, pr, token, body):
+        raise typer.Exit(5)
+
+    if config.collapse_previous_code_review_comments:
+        sleep(1)
+        collapse_gh_outdated_cr_comments(gh_repo, pr, token)
+
+
+def collapse_gh_outdated_cr_comments(
+    gh_repository: str,
+    pr_or_issue_number: int,
+    token: str = None
+):
+    """
+    Collapse outdated code review comments in a GitHub pull request or issue.
+    """
+    logging.info(f"Collapsing outdated comments in {gh_repository} #{pr_or_issue_number}...")
+
+    token = resolve_gh_token(token)
+    owner, repo = gh_repository.split('/')
+    api = GhApi(owner, repo, token=token)
+
+    comments = api.issues.list_comments(pr_or_issue_number)
+    review_marker = HTML_CR_COMMENT_MARKER
+    collapsed_title = "🗑️ Outdated Code Review by Gito"
+    collapsed_marker = f"<summary>{collapsed_title}</summary>"
+    outdated_comments = [
+        c for c in comments
+        if c.body and review_marker in c.body and collapsed_marker not in c.body
+    ][:-1]
+    if not outdated_comments:
+        logging.info("No outdated comments found")
+        return
+    for comment in outdated_comments:
+        logging.info(f"Collapsing comment {comment.id}...")
+        new_body = f"<details>\n<summary>{collapsed_title}</summary>\n\n{comment.body}\n</details>"
+        api.issues.update_comment(comment.id, new_body)
+        hide_gh_comment(comment.node_id, token)
+    logging.info("All outdated comments collapsed successfully.")

{ai_cr-2.0.2 → ai_cr-3.0.0}/gito/commands/gh_react_to_comment.py

@@ -16,10 +16,10 @@ from microcore import ui
 from ghapi.all import GhApi
 import git
 
-from ..bootstrap import app
+from ..cli_base import app
 from ..constants import JSON_REPORT_FILE_NAME, HTML_TEXT_ICON
 from ..core import answer
-from ..gh_api import post_gh_comment
+from ..gh_api import post_gh_comment, resolve_gh_token
 from ..project_config import ProjectConfig
 from ..utils import extract_gh_owner_repo
 from .fix import fix
@@ -51,9 +51,7 @@ def react_to_comment(
     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)
-    )
+    gh_token = resolve_gh_token(gh_token)
     api = GhApi(owner=owner, repo=repo_name, token=gh_token)
     comment = api.issues.get_comment(comment_id=comment_id)
     logging.info(