ai-cr 2.0.0.dev1__py3-none-any.whl → 2.0.1__py3-none-any.whl

gito/commands/fix.py

@@ -1,124 +1,157 @@
-"""
-Fix issues from code review report
-"""
-import json
-import logging
-from pathlib import Path
-from typing import Optional
-
-import typer
-from microcore import ui
-
-from ..bootstrap import app
-from ..constants import JSON_REPORT_FILE_NAME
-from ..report_struct import Report
-
-
-@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"
-    ),
-):
-    """
-    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 = 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")
+"""
+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_post_review_comment.py

@@ -0,0 +1,63 @@
+import logging
+import os
+
+import typer
+from gito.bootstrap import app
+from gito.constants import GITHUB_MD_REPORT_FILE_NAME
+from gito.gh_api import post_gh_comment
+from gito.project_config import ProjectConfig
+
+
+@app.command(help="Leave a GitHub PR comment with the review.")
+def github_comment(
+    token: str = typer.Option(
+        os.environ.get("GITHUB_TOKEN", ""), help="GitHub token (or set GITHUB_TOKEN env var)"
+    ),
+):
+    """
+    Leaves a comment with the review on the current GitHub pull request.
+    """
+    file = 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()
+
+    if not token:
+        print("GitHub token is required (--token or GITHUB_TOKEN env var).")
+        raise typer.Exit(1)
+
+    github_env = ProjectConfig.load().prompt_vars["github_env"]
+    repo = github_env.get("github_repo", "")
+    pr_env_val = github_env.get("github_pr_number", "")
+    logging.info(f"github_pr_number = {pr_env_val}")
+
+    pr = None
+    # 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(repo, pr, token, body):
+        raise typer.Exit(5)

gito/commands/gh_react_to_comment.py

@@ -0,0 +1,194 @@
+"""
+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 microcore import ui
+from ghapi.all import GhApi
+import git
+
+from ..bootstrap import app
+from ..constants import JSON_REPORT_FILE_NAME, HTML_TEXT_ICON
+from ..core import answer
+from ..gh_api import post_gh_comment
+from ..project_config import ProjectConfig
+from ..utils import extract_gh_owner_repo
+from .fix import fix
+
+
+@app.command(hidden=True)
+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"
+    ),
+):
+    """
+    Handles direct agent instructions from pull request comments.
+
+    Note: Not for local usage. Designed for execution within GitHub Actions workflows.
+
+    Fetches the PR comment by ID, parses agent directives, and executes the requested
+    actions automatically to enable seamless code review workflow integration.
+    """
+    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
+    try:
+        logging.info("Comment contains mention trigger, reacting with 'eyes'.")
+        api.reactions.create_for_issue_comment(comment_id=comment_id, content="eyes")
+    except Exception as e:
+        logging.error("Error reacting to comment with emoji: %s", str(e))
+    pr = int(comment.issue_url.split("/")[-1])
+    print(f"Processing comment for PR #{pr}...")
+
+    issue_ids = extract_fix_args(comment.body)
+    if issue_ids:
+        logging.info(f"Extracted issue IDs: {ui.yellow(str(issue_ids))}")
+        out_folder = "artifact"
+        download_latest_code_review_artifact(
+            api, pr_number=pr, gh_token=gh_token, out_folder=out_folder
+        )
+        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.")
+    elif is_review_request(comment.body):
+        ref = repo.active_branch.name
+        logging.info(f"Triggering code-review workflow, ref='{ref}'")
+        api.actions.create_workflow_dispatch(
+            workflow_id="gito-code-review.yml",
+            ref=ref,
+            inputs={"pr_number": str(pr)},
+        )
+    else:
+        if cfg.answer_github_comments:
+            response = answer(comment.body, repo=repo)
+            post_gh_comment(
+                gh_repository=f"{owner}/{repo_name}",
+                pr_or_issue_number=pr,
+                gh_token=gh_token,
+                text=HTML_TEXT_ICON+response,
+            )
+        else:
+            ui.error("Can't identify target command in the text.")
+            return
+
+
+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 []
+
+
+def is_review_request(text: str) -> bool:
+    text = text.lower().strip()
+    trigger_words = ['review', 'run', 'code-review']
+    if any(f"/{word}" in text for word in trigger_words):
+        return True
+    parts = text.split()
+    if len(parts) == 2 and parts[1] in trigger_words:
+        return True
+    return False

gito/commands/repl.py

@@ -4,8 +4,7 @@ Python REPL
 # flake8: noqa: F401
 import code
 
-
-# Imports for usage in REPL
+# Wildcard imports are preferred to capture most of functionality for usage in REPL
 import os
 import sys
 from dataclasses import dataclass
@@ -18,6 +17,10 @@ import microcore as mc
 from microcore import ui
 
 from ..cli import app
+from ..constants import *
+from ..core import *
+from ..utils import *
+
 
 @app.command(help="python REPL")
 def repl():