ai-cr 0.1.0__py3-none-any.whl → 0.4.3__py3-none-any.whl

ai_code_review/.ai-code-review.toml

@@ -0,0 +1,305 @@
+report_template_md = """
+# 🤖 I've Reviewed the Code
+
+{% if report.summary -%}
+    {{ report.summary }}
+{%- endif %}
+
+**{%- if report.total_issues > 0 %}⚠️{% endif -%}
+Total issues: `{{ report.total_issues }}`
+{{- ' ' -}}
+in `{{ report.number_of_processed_files }}` files**
+
+{%- for issue in report.plain_issues -%}
+    {{"\n"}}## `#{{ issue.id}}`  {{ issue.title -}}
+    {{ "\n"}}[{{ issue.file }}{{' '}}
+
+    {%- if issue.affected_lines -%}
+        {%- for i in issue.affected_lines -%}
+        L{{ i.start_line }}{%- if i.end_line != i.start_line -%}-L{{ i.end_line }}{%- endif -%}
+        {%- if loop.last == false -%}, {%- endif -%}
+        {%- endfor -%}
+    {%- endif -%}
+    ]({{ issue.github_code_link(github_env) }})
+
+    {{"\n"}}{{ issue.details -}}
+    {{"\n"}}**Tags: {{ ', '.join(issue.tags) }}**
+    {%- for i in issue.affected_lines -%}
+        {%- if i.affected_code %}\n**Affected code:**\n```{{ i.syntax_hint }}\n{{ i.affected_code }}\n```{%- endif -%}
+        {%- if i.proposal %}\n**Proposed change:**\n```{{ i.syntax_hint }}\n{{ i.proposal }}\n```{%- endif -%}
+    {%- endfor -%}
+    {{ "\n" }}
+{%- endfor -%}
+
+"""
+retries = 3
+prompt = """
+{{ self_id }}
+----TASK----
+Review the provided code diff carefully and identify *only* highly confident issues which are relevant to any code context.
+
+----CODE----
+{{ input }}
+--------
+
+{% if file_lines -%}
+----ADDITIONAL CONTEXT----
+{{ file_lines }}
+{%- endif %}
+
+----TASK GUIDELINES----
+- Only report issues you are **100% confident** are relevant to any context.
+- Only include issues that are **significantly valuable** to the maintainers (e.g., bugs, security flaws, or clear maintainability concerns).
+- Do **not** report vague, theoretical, or overly generic advice.
+- Do **not** report anything with medium or lower confidence.
+{{ json_requirements }}
+
+Respond with a valid JSON array of issues in the following format:
+[
+    {
+        "title": "<issue_title>",
+        "details": "<issue_description>",
+        "tags": ["<issue_tag1>", "<issue_tag2>"],
+        "severity": <issue_severity>,
+        "confidence": <confidence_score>
+        "affected_lines": [ // optional; list of affected lines
+            {
+                "start_line": <start_line:int>,
+                "end_line": <end_line:int>,
+                "proposal": "<proposed code to replace the affected lines (optional)>"
+            },
+            ...
+        ]
+    },
+    ...
+]
+Available issue tags:
+- bug
+- security
+- performance
+- readability
+- maintainability
+- overcomplexity
+- language
+- architecture
+- compatibility
+- deprecation
+- anti-pattern
+- naming
+- code-style
+
+Issue severity scale:
+- 1 — Critical
+- 2 — Major
+- 3 — Minor
+- 4 — Trivial
+- 5 — Suggestion
+
+Confidence scale:
+- 1 — Highest, 100% confidence that code requires changes in any context
+- 2 — Very High
+- 3 — High
+- 4 — Medium - Should not be reported
+
+(!) - If no issues found according to the criterias, respond with empty list: []
+"""
+# Remove issues with confidence + severity > 3
+post_process = """
+for fn in issues:
+    issues[fn] = [
+        i for i in issues[fn]
+        if i["confidence"] == 1 and i["severity"] <= 2
+    ]
+"""
+summary_prompt = """
+{{ self_id }}
+Summarize the code review in one sentence.
+--Reviewed Changes--
+{% for part in diff %}{{ part }}\n{% endfor %}
+--Detected Issues--
+{{ issues | tojson(indent=2) }}
+---
+If code changs contains exceptional achievements, you may additionally present the award in summary text.
+--Available Awards--
+{{ awards }}
+---
+Your response will be parsed programmatically, so do not include any additional text.
+Use Markdown formatting in your response.
+"""
+
+[prompt_vars]
+self_id = """
+You are a subsystem of an AI-powered software platform, specifically tasked with performing expert code reviews.
+Act as a senior, highly experienced software engineer.
+"""
+json_requirements = """
+- ⚠️ IMPORTANT: RESPOND ONLY WITH VALID JSON, YOUR RESPONSE WILL BE PARSED PROGRAMMATICALLY.
+- Do not include any additional text or explanation outside the specified format.
+"""
+awards = """
+## 🧙‍♂️ "Refactoring Archmage"
+**For:** Elegantly transforming complex code into simple code without losing functionality.
+
+**Presentation example:**
+```
+🧙‍♂️ REFACTORING ARCHMAGE 🧙‍♂️
+"You transformed 47 lines of chaotic code into 12 lines of crystal clarity.
+Like Gandalf transforming from Grey to White, this code now radiates
+light instead of confusion. The coding magic school gives a standing ovation."
+```
+
+## 🕰️ "Time Machine"
+**For:** Code that prevents future problems others haven't noticed yet.
+
+**Presentation example:**
+```
+🕰️ TIME MACHINE 🕰️
+"Your edge case handler just saved the company from a dark
+alternative timeline where at 3:00 AM next month
+the DevOps team goes crazy from incomprehensible errors. History has changed,
+the future is no longer what it was."
+```
+
+## 🎭 "Shakespearean Playwright"
+**For:** Exceptionally expressive variable and function names that tell a story.
+
+**Presentation example:**
+```
+🎭 SHAKESPEAREAN PLAYWRIGHT 🎭
+"'processUserInputAndValidateBeforeSending' — a whole act of drama in one
+function name! Such clarity of intent, such drama! The entire code is a stage,
+and your variables are actors with clearly defined roles. The audience is thrilled."
+```
+
+## 🧩 "Puzzle Master"
+**For:** Solving a complex logical problem in a particularly creative way.
+
+**Presentation example:**
+```
+🧩 PUZZLE MASTER 🧩
+"Where others saw impassable thickets of conditions, you paved an elegant algorithmic
+path. Your solution looks so natural that now it seems like there could never have been
+another way. Rubik applauds."
+```
+
+## 🐛 "Ghostbuster"
+**For:** Detecting and fixing elusive bugs or potential issues.
+
+**Presentation example:**
+```
+🐛 GHOSTBUSTER 🐛
+"This elusive bug was hiding in the shadows for five sprints, feeding on developers'
+souls and sowing chaos. 'Who are you?' it screamed when you dragged it into the light
+with your precise fix. Paranormal activity eliminated."
+```
+
+## 🏛️ "Architectural Virtuoso"
+**For:** Code structuring that promotes extensibility and flexibility.
+
+**Presentation example:**
+```
+🏛️ ARCHITECTURAL VIRTUOSO 🏛️
+"Your architecture is like the Parthenon of modern code: proportional, harmonious, and seems
+to withstand the pressure of time and changing requirements. Vitruvius records your patterns
+for future generations."
+```
+
+## 🧬 "Code Geneticist"
+**For:** Successful use of inheritance/composition or other complex OOP concepts.
+
+**Presentation example:**
+```
+🧬 CODE GENETICIST 🧬
+"Your elegant inheritance chain has mutated the code into a new life form — more
+adaptive, more evolutionarily stable. Natural selection kindly approved these changes,
+while unacceptable complexity remains in the paleontological past of development."
+```
+
+## 🔄 "Zen of Loops"
+**For:** Writing particularly efficient and understandable loops/iterations.
+
+**Presentation example:**
+```
+🔄 ZEN OF LOOPS 🔄
+"Your loop impresses with its laconic wisdom. Nothing extra, nothing forgotten,
+perfect balance between readability and performance. 'Before writing a loop,
+think whether it's needed at all,' says the master. Your loop — is needed."
+```
+
+## 🛡️ "Gate Guardian"
+**For:** Excellent input validation and protection against edge cases.
+
+**Presentation example:**
+```
+🛡️ GATE GUARDIAN 🛡️
+"No bad data shall pass your vigilant defense. Users may enter
+the most bizarre combinations, but your code stands firm, like a sentinel at the gates
+of the data city. 'You shall not pass!' it speaks to invalid format."
+```
+
+## 🎨 "Readability Impressionist"
+**For:** Code that reads like well-written prose.
+
+**Presentation example:**
+```
+🎨 READABILITY IMPRESSIONIST 🎨
+"Reading your code, you feel sunlight falling on the water lilies of clarity,
+like a breeze playing in the willows of logic. Each line is a brush stroke,
+and together they create a picture that can be understood at first glance."
+```
+
+## 🚀 "Optimization Pioneer"
+**For:** Significant performance improvement without sacrificing readability.
+
+**Presentation example:**
+```
+🚀 OPTIMIZATION PIONEER 🚀
+"Oh! Your algorithm now flies at the speed of light! If it used to crawl
+like a snail through O(n²) sand, now it races down the O(log n) highway.
+The passengers of this code won't even notice how they arrive at their destination!"
+```
+
+## 📚 "Code Chronicler"
+**For:** Exceptionally useful and informative comments.
+
+**Presentation example:**
+```
+📚 CODE CHRONICLER 📚
+"Your comments are like an ancient manuscript revealing the secrets of forgotten civilizations.
+'And there was light,' you said, and indeed the light bulb of understanding lit up above the heads
+of all who will read this code in the future."
+```
+
+## 🧪 "Testing Alchemist"
+**For:** Writing particularly creative and thorough tests.
+
+**Presentation example:**
+```
+🧪 TESTING ALCHEMIST 🧪
+"In your testing crucible you mixed reagents of edge cases, catalyst
+of boundary conditions and essence of unit tests. The philosopher's stone of quality was born —
+your code is now immortal in the face of regression!"
+```
+
+## 🗿 "Ancient Artifact Decoder"
+**For:** Successfully working with complex legacy code.
+
+**Presentation example:**
+```
+🗿 ANCIENT ARTIFACT DECODER 🗿
+"You stand among the ruins of code written five years ago in the forgotten language of the ancients.
+Like Champollion with the Rosetta Stone, you deciphered the hieroglyphs of functions,
+restored lost knowledge and now bestow it upon a new generation."
+```
+
+## 🎵 "Pattern Composer"
+**For:** Sophisticated application or combination of multiple design patterns.
+
+**Presentation example:**
+```
+🎵 PATTERN COMPOSER 🎵
+"Your symphony of patterns sounds magnificent! Factory method opens the first movement,
+decorators add depth and texture, and observer masterfully completes the composition.
+The Gang of Four gives a standing ovation from the stalls."
+```
+"""

ai_code_review/bootstrap.py

@@ -0,0 +1,37 @@
+import logging
+from datetime import datetime
+
+import microcore as mc
+
+from .constants import ENV_CONFIG_FILE
+
+
+def setup_logging():
+    class CustomFormatter(logging.Formatter):
+        def format(self, record):
+            dt = datetime.fromtimestamp(record.created).strftime("%Y-%m-%d %H:%M:%S")
+            message, level_name = record.getMessage(), record.levelname
+            if record.levelno == logging.WARNING:
+                message = mc.ui.yellow(message)
+                level_name = mc.ui.yellow(level_name)
+            if record.levelno >= logging.ERROR:
+                message = mc.ui.red(message)
+                level_name = mc.ui.red(level_name)
+            return f"{dt} {level_name}: {message}"
+
+    handler = logging.StreamHandler()
+    handler.setFormatter(CustomFormatter())
+    logging.basicConfig(level=logging.INFO, handlers=[handler])
+
+
+def bootstrap():
+    """Bootstrap the application with the environment configuration."""
+    setup_logging()
+    logging.info("Bootstrapping...")
+    mc.configure(
+        DOT_ENV_FILE=ENV_CONFIG_FILE,
+        VALIDATE_CONFIG=False,
+        USE_LOGGING=True,
+        EMBEDDING_DB_TYPE=mc.EmbeddingDbType.NONE,
+    )
+    mc.logging.LoggingConfig.STRIP_REQUEST_LINES = [100, 15]

ai_code_review/cli.py

@@ -0,0 +1,112 @@
+import asyncio
+import logging
+import sys
+import os
+import shutil
+
+import microcore as mc
+import async_typer
+import typer
+from .core import review
+from .report_struct import Report
+from git import Repo
+import requests
+
+from .constants import ENV_CONFIG_FILE
+from .bootstrap import bootstrap
+from .project_config import ProjectConfig
+
+app = async_typer.AsyncTyper(
+    pretty_exceptions_show_locals=False,
+)
+
+
+if sys.platform == "win32":
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+
+@app.callback(invoke_without_command=True)
+def cli(ctx: typer.Context, filters=typer.Option("", "--filter", "-f", "--filters")):
+    if ctx.invoked_subcommand != "setup":
+        bootstrap()
+    if not ctx.invoked_subcommand:
+        asyncio.run(review(filters=filters))
+
+
+@app.async_command(help="Configure LLM for local usage interactively")
+async def setup():
+    mc.interactive_setup(ENV_CONFIG_FILE)
+
+
+@app.async_command()
+async def render(format: str = Report.Format.MARKDOWN):
+    print(Report.load().render(format=format))
+
+
+@app.async_command(help="Review remote code")
+async def remote(url=typer.Option(), branch=typer.Option()):
+    if os.path.exists("reviewed-repo"):
+        shutil.rmtree("reviewed-repo")
+    Repo.clone_from(url, branch=branch, to_path="reviewed-repo")
+    prev_dir = os.getcwd()
+    try:
+        os.chdir("reviewed-repo")
+        await review()
+    finally:
+        os.chdir(prev_dir)
+
+
+@app.async_command(help="Leave a GitHub PR comment with the review.")
+async 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 = "code-review-report.txt"
+    if not os.path.exists(file):
+        print(f"Review file not found: {file}")
+        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}")
+
+    # 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:
+            pr = 0
+    else:
+        try:
+            pr = int(pr_env_val)
+        except Exception:
+            pr = 0
+
+    api_url = f"https://api.github.com/repos/{repo}/issues/{pr}/comments"
+    headers = {
+        "Authorization": f"token {token}",
+        "Accept": "application/vnd.github+json",
+    }
+    data = {"body": body}
+
+    resp = requests.post(api_url, headers=headers, json=data)
+    if 200 <= resp.status_code < 300:
+        logging.info(f"Posted review comment to PR #{pr} in {repo}")
+    else:
+        logging.error(f"Failed to post comment: {resp.status_code} {resp.reason}\n{resp.text}")
+        raise typer.Exit(5)

ai_code_review/constants.py

@@ -0,0 +1,7 @@
+from pathlib import Path
+
+
+PROJECT_CONFIG_FILE = Path(".ai-code-review.toml")
+PROJECT_CONFIG_DEFAULTS_FILE = Path(__file__).resolve().parent / PROJECT_CONFIG_FILE
+ENV_CONFIG_FILE = Path("~/.env.ai-code-review").expanduser()
+JSON_REPORT_FILE_NAME = "code-review-report.json"

ai_code_review/core.py

@@ -0,0 +1,114 @@
+import fnmatch
+import logging
+from typing import Iterable
+
+import microcore as mc
+from git import Repo
+from unidiff import PatchSet, PatchedFile
+from unidiff.constants import DEV_NULL
+
+from .project_config import ProjectConfig
+from .report_struct import Report
+
+
+def get_diff(repo: Repo = None, against: str = "HEAD") -> PatchSet | list[PatchedFile]:
+    repo = repo or Repo(".")
+    base = repo.remotes.origin.refs.HEAD.reference.name
+    logging.info(f"{base}...{against}")
+    diff_content = repo.git.diff(base, against)
+    diff = PatchSet.from_string(diff_content)
+    return diff
+
+
+def filter_diff(
+    patch_set: PatchSet | Iterable[PatchedFile], filters: str | list[str]
+) -> PatchSet | Iterable[PatchedFile]:
+    """
+    Filter the diff files by the given fnmatch filters.
+    """
+    print([f.path for f in patch_set])
+    assert isinstance(filters, (list, str))
+    if not isinstance(filters, list):
+        filters = [f.strip() for f in filters.split(",") if f.strip()]
+    if not filters:
+        return patch_set
+    files = [
+        file
+        for file in patch_set
+        if any(fnmatch.fnmatch(file.path, pattern) for pattern in filters)
+    ]
+    print([f.path for f in files])
+    return files
+
+
+def file_lines(repo: Repo, file: str, max_tokens: int = None) -> str:
+    text = repo.tree()[file].data_stream.read().decode()
+    lines = [f"{i + 1}: {line}\n" for i, line in enumerate(text.splitlines())]
+    if max_tokens:
+        lines, removed_qty = mc.tokenizing.fit_to_token_size(lines, max_tokens)
+        if removed_qty:
+            lines.append(
+                f"(!) DISPLAYING ONLY FIRST {len(lines)} LINES DUE TO LARGE FILE SIZE\n"
+            )
+    return "".join(lines)
+
+
+def make_cr_summary(cfg: ProjectConfig, report: Report, diff):
+    return mc.prompt(
+        cfg.summary_prompt,
+        diff=mc.tokenizing.fit_to_token_size(diff, cfg.max_code_tokens)[0],
+        issues=report.issues,
+        **cfg.prompt_vars,
+    ).to_llm() if cfg.summary_prompt else ""
+
+
+async def review(filters: str | list[str] = ""):
+    cfg = ProjectConfig.load()
+    repo = Repo(".")
+    diff = get_diff(repo=repo, against="HEAD")
+    diff = filter_diff(diff, filters)
+    if not diff:
+        logging.error("Nothing to review")
+        return
+    lines = {
+        file_diff.path: (
+            file_lines(
+                repo,
+                file_diff.path,
+                cfg.max_code_tokens
+                - mc.tokenizing.num_tokens_from_string(str(file_diff)),
+            )
+            if file_diff.target_file != DEV_NULL
+            else ""
+        )
+        for file_diff in diff
+    }
+    responses = await mc.llm_parallel(
+        [
+            mc.prompt(
+                cfg.prompt,
+                input=file_diff,
+                file_lines=lines[file_diff.path],
+                **cfg.prompt_vars,
+            )
+            for file_diff in diff
+        ],
+        retries=cfg.retries,
+        parse_json=True,
+    )
+    issues = {file.path: issues for file, issues in zip(diff, responses) if issues}
+    for file, file_issues in issues.items():
+        for issue in file_issues:
+            for i in issue.get("affected_lines", []):
+                if lines[file]:
+                    f_lines = [""] + lines[file].splitlines()
+                    i["affected_code"] = "\n".join(
+                        f_lines[i["start_line"]: i["end_line"]+1]
+                    )
+    exec(cfg.post_process, {"mc": mc, **locals()})
+    report = Report(issues=issues, number_of_processed_files=len(diff))
+    report.summary = make_cr_summary(cfg, report, diff)
+    report.save()
+    report_text = report.render(cfg, Report.Format.MARKDOWN)
+    print(mc.ui.yellow(report_text))
+    open("code-review-report.txt", "w", encoding="utf-8").write(report_text)

ai_code_review/project_config.py

@@ -0,0 +1,99 @@
+import logging
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import microcore as mc
+
+from .constants import PROJECT_CONFIG_FILE, PROJECT_CONFIG_DEFAULTS_FILE
+
+
+def _detect_github_env() -> dict:
+    """
+    Try to detect GitHub repository/PR info from environment variables (for GitHub Actions).
+    Returns a dict with github_repo, github_pr_sha, github_pr_number, github_ref, etc.
+    """
+    import os
+
+    repo = os.environ.get("GITHUB_REPOSITORY", "")
+    pr_sha = os.environ.get("GITHUB_SHA", "")
+    pr_number = os.environ.get("GITHUB_REF", "")
+    branch = ""
+    ref = os.environ.get("GITHUB_REF", "")
+    # Try to resolve PR head SHA if available.
+    # On PRs, GITHUB_HEAD_REF/BASE_REF contain branch names.
+    if "GITHUB_HEAD_REF" in os.environ:
+        branch = os.environ["GITHUB_HEAD_REF"]
+    elif ref.startswith("refs/heads/"):
+        branch = ref[len("refs/heads/"):]
+    elif ref.startswith("refs/pull/"):
+        # for pull_request events
+        branch = ref
+
+    d = {
+        "github_repo": repo,
+        "github_pr_sha": pr_sha,
+        "github_pr_number": pr_number,
+        "github_branch": branch,
+        "github_ref": ref,
+    }
+    # Fallback for local usage: try to get from git
+    if not repo:
+        try:
+            from git import Repo as GitRepo
+
+            git = GitRepo(".", search_parent_directories=True)
+            origin = git.remotes.origin.url
+            # e.g. git@github.com:Nayjest/ai-code-review.git -> Nayjest/ai-code-review
+            import re
+
+            match = re.search(r"[:/]([\w\-]+)/([\w\-\.]+?)(\.git)?$", origin)
+            if match:
+                d["github_repo"] = f"{match.group(1)}/{match.group(2)}"
+            d["github_pr_sha"] = git.head.commit.hexsha
+            d["github_branch"] = (
+                git.active_branch.name if hasattr(git, "active_branch") else ""
+            )
+        except Exception:
+            pass
+    # If branch is not a commit SHA, prefer branch for links
+    if d["github_branch"]:
+        d["github_pr_sha_or_branch"] = d["github_branch"]
+    elif d["github_pr_sha"]:
+        d["github_pr_sha_or_branch"] = d["github_pr_sha"]
+    else:
+        d["github_pr_sha_or_branch"] = "main"
+    return d
+
+
+@dataclass
+class ProjectConfig:
+    prompt: str = ""
+    summary_prompt: str = ""
+    report_template_md: str = ""
+    """Markdown report template"""
+    post_process: str = ""
+    retries: int = 3
+    """LLM retries for one request"""
+    max_code_tokens: int = 32000
+    prompt_vars: dict = field(default_factory=dict)
+
+    @staticmethod
+    def load(custom_config_file: str | Path | None = None) -> "ProjectConfig":
+        config_file = Path(custom_config_file or PROJECT_CONFIG_FILE)
+        with open(PROJECT_CONFIG_DEFAULTS_FILE, "rb") as f:
+            config = tomllib.load(f)
+        github_env = _detect_github_env()
+        config["prompt_vars"] |= github_env | dict(github_env=github_env)
+        if config_file.exists():
+            logging.info(
+                f"Loading project-specific configuration from {mc.utils.file_link(config_file)}...")
+            default_prompt_vars = config["prompt_vars"]
+            with open(config_file, "rb") as f:
+                config.update(tomllib.load(f))
+            # overriding prompt_vars config section will not empty default values
+            config["prompt_vars"] = default_prompt_vars | config["prompt_vars"]
+        else:
+            logging.info(f"Config file {config_file} not found, using defaults")
+
+        return ProjectConfig(**config)