ai-cr 2.0.2__py3-none-any.whl → 3.0.0__py3-none-any.whl

gito/commands/gh_post_review_comment.py

@@ -1,23 +1,33 @@
 import logging
 import os
+from time import sleep
 
 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
+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(help="Leave a GitHub PR comment with the review.")
-def github_comment(
+
+@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(
-        os.environ.get("GITHUB_TOKEN", ""), help="GitHub token (or set GITHUB_TOKEN env var)"
+        "", 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
+    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)
@@ -25,30 +35,31 @@ def github_comment(
     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)
-
-    github_env = ProjectConfig.load().prompt_vars["github_env"]
-    repo = github_env.get("github_repo", "")
-    pr_env_val = github_env.get("github_pr_number", "")
+    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}")
 
-    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:
+        # 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:
@@ -59,5 +70,42 @@ def github_comment(
         logging.error("Could not resolve PR number from environment variables.")
         raise typer.Exit(3)
 
-    if not post_gh_comment(repo, pr, token, body):
+    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.")

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(

gito/commands/linear_comment.py

@@ -0,0 +1,53 @@
+import os
+import sys
+import logging
+
+import typer
+from git import Repo
+
+from ..cli_base import app, arg_refs
+from ..issue_trackers import resolve_issue_key
+
+import requests
+
+
+def post_linear_comment(issue_key, text, api_key):
+    response = requests.post(
+       'https://api.linear.app/graphql',
+       headers={'Authorization': api_key, 'Content-Type': 'application/json'},
+       json={
+           'query': '''
+               mutation($issueId: String!, $body: String!) {
+                   commentCreate(input: {issueId: $issueId, body: $body}) {
+                       comment { id }
+                   }
+               }
+           ''',
+           'variables': {'issueId': issue_key, 'body': text}
+       }
+    )
+    return response.json()
+
+
+@app.command()
+def linear_comment(
+    text: str = typer.Argument(None),
+    refs: str = arg_refs(),
+):
+    if text is None or text == "-":
+        # Read from stdin if no text provided
+        text = sys.stdin.read()
+
+    if not text or not text.strip():
+        typer.echo("Error: No comment text provided.", err=True)
+        raise typer.Exit(code=1)
+
+    api_key = os.getenv("LINEAR_API_KEY")
+    if not api_key:
+        logging.error("LINEAR_API_KEY environment variable is not set")
+        return
+
+    repo = Repo(".")
+    key = resolve_issue_key(repo)
+    post_linear_comment(key, text, api_key)
+    logging.info("Comment posted to Linear issue %s", key)

gito/commands/repl.py

@@ -16,10 +16,11 @@ from rich.pretty import pprint
 import microcore as mc
 from microcore import ui
 
-from ..cli import app
+from ..cli_base import app
 from ..constants import *
 from ..core import *
 from ..utils import *
+from ..gh_api import *
 
 
 @app.command(help="python REPL")

gito/config.toml

@@ -3,6 +3,7 @@
 # Defines the keyword or mention tag that triggers bot actions when referenced in code review comments.
 # list of strings, case-insensitive
 mention_triggers = ["gito", "bot", "ai", "/fix"]
+collapse_previous_code_review_comments = true
 report_template_md = """
 <h2>{{ HTML_TEXT_ICON }}I've Reviewed the Code</h2>
 
@@ -36,7 +37,7 @@ report_template_md = """
     {%- endfor -%}
     {{ "\n" }}
 {%- endfor -%}
-
+{{- HTML_CR_COMMENT_MARKER -}}
 """
 report_template_cli = """
 {{ Back.BLUE }}  +  +  +  ---==<<[ CODE REVIEW{{Style.NORMAL}} ]>>==---  +  +  +  {{Style.RESET_ALL}}
@@ -49,7 +50,7 @@ report_template_cli = """
 {%- if report.summary -%}
     {{- "\n" }}
     {{- "\n" }}{{- Style.BRIGHT }}✨  SUMMARY {{ Style.RESET_ALL -}}
-    {{- "\n" }}{{- report.summary -}}
+    {{- "\n" }}{{- remove_html_comments(report.summary) -}}
 {%- endif %}
 {% for issue in report.plain_issues -%}
     {{"\n"}}{{ Style.BRIGHT }}{{Back.RED}}[ {{ issue.id}} ]{{Back.RESET}}  {{ issue.title -}}{{ Style.RESET_ALL -}}
@@ -134,18 +135,18 @@ Review the provided code diff carefully and identify *only* highly confident iss
 {{ requirements -}}
 {{ json_requirements }}
 
-Respond with a valid JSON array of issues in the following format:
+Respond with a valid JSON array of issues following this schema:
 [
     {
         "title": "<issue_title>",
         "details": "<issue_description>",
-        "tags": ["<issue_tag1>", "<issue_tag2>"],
-        "severity": <issue_severity>,
-        "confidence": <confidence_score>,
-        "affected_lines": [ // optional; list of affected lines
+        "tags": ["<issue_tag1>", "<issue_tag2>", ...],
+        "severity": <issue_severity:int>,
+        "confidence": <confidence_score:int>,
+        "affected_lines": [ // optional;
             {
-                "start_line": <start_line:int>,
-                "end_line": <end_line:int>,
+                "start_line": <int>,
+                "end_line": <int>,
                 "proposal": "<proposed code to replace the affected lines (optional)>"
             },
             ...
@@ -153,6 +154,10 @@ Respond with a valid JSON array of issues in the following format:
     },
     ...
 ]
+
+- if present, `proposal` blocks must match the indentation of the original code
+  and apply cleanly to lines `start_line`..`end_line`. It is designed for programmatical substitution.
+
 Available issue tags:
 - bug
 - security
@@ -200,14 +205,16 @@ Summarize the code review in one sentence.
 {{ issues | tojson(indent=2) }}
 ---
 If the code changes include exceptional achievements, you may also present an award to the author in the summary text.
-Note: Awards should only be given to authors of initial codebase changes, not to code reviewers.
+ - (!) Only give awards to initial codebase authors, NOT to reviewers.
+ - (!) If you give an award, place the hidden <!-- award --> HTML comment on its own line immediately before the award text.
 --Available Awards--
 {{ awards }}
 ---
 {% if pipeline_out.associated_issue and pipeline_out.associated_issue.title %}
 ----SUBTASK----
 Include one sentence about how the code changes address the requirements of the associated issue listed below.
-
+- (!) Place the hidden <!-- issue_alignment --> comment on its own line immediately before the related text.
+- Use ✅ or ⚠️ to indicate whether the implementation fully satisfies the issue requirements.
 --Associated Issue--
 # {{ pipeline_out.associated_issue.title }}
 {{ pipeline_out.associated_issue.description }}
@@ -218,10 +225,12 @@ Examples:
 
 If the implementation fully delivers the requested functionality:
 ```
+<!-- issue_alignment -->
 ✅  Implementation Satisfies [<ISSUE_KEY>](<ISSUE_URL>).
 ```
 If there are concerns about how thoroughly the code covers the requirements and technical description from the associated issue:
 ```
+<!-- issue_alignment -->
 ⚠️ <Describe specific gap or concern>.
 ⚠️ <Describe additional limitation or missing feature>.
 ```
@@ -248,6 +257,14 @@ Answer the following user question:
 --FILE: {{ file }}--
 {{ file_lines }}
 {% endfor %}
+
+{%- if pipeline_out.associated_issue and pipeline_out.associated_issue.title %}
+----ASSOCIATED ISSUE----
+# {{ pipeline_out.associated_issue.title }}
+{{ pipeline_out.associated_issue.description }}
+URL: {{ pipeline_out.associated_issue.url }}
+{%- endif -%}{{ '\n' }}
+
 ----ANSWERING INSTRUCTIONS----
 {{ answering_instructions }}
 """
@@ -433,7 +450,9 @@ decorators add depth and texture, and observer masterfully completes the composi
 The Gang of Four gives a standing ovation from the stalls."
 ```
 """
-requirements = ""
+requirements = """
+- (!) Never report issues related to software versions, model names, or similar details that you believe have not yet been released—you cannot reliably determine this.
+"""
 summary_requirements = ""
 answering_instructions = """
 - (!) Provide a concise, direct answer in engaging speech.

gito/constants.py

@@ -10,3 +10,4 @@ GITHUB_MD_REPORT_FILE_NAME = "code-review-report.md"
 EXECUTABLE = "gito"
 TEXT_ICON_URL = 'https://raw.githubusercontent.com/Nayjest/Gito/main/press-kit/logo/gito-bot-1_64top.png'  # noqa: E501
 HTML_TEXT_ICON = f'<a href="https://github.com/Nayjest/Gito"><img src="{TEXT_ICON_URL}" align="left" width=64 height=50 /></a>'  # noqa: E501
+HTML_CR_COMMENT_MARKER = '<!-- GITO_COMMENT:CODE_REVIEW_REPORT -->'

gito/context.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass, field
+from typing import Iterable, TYPE_CHECKING
+
+from unidiff.patch import PatchSet, PatchedFile
+from git import Repo
+
+
+if TYPE_CHECKING:
+    from .project_config import ProjectConfig
+    from .report_struct import Report
+
+
+@dataclass
+class Context:
+    report: "Report"
+    config: "ProjectConfig"
+    diff: PatchSet | Iterable[PatchedFile]
+    repo: Repo
+    pipeline_out: dict = field(default_factory=dict)

gito/core.py

@@ -3,17 +3,22 @@ import logging
 from os import PathLike
 from typing import Iterable
 from pathlib import Path
+from functools import partial
 
 import microcore as mc
-from git import Repo
-from gito.pipeline import Pipeline
+from microcore import ui
+from git import Repo, Commit
+from git.exc import GitCommandError
 from unidiff import PatchSet, PatchedFile
 from unidiff.constants import DEV_NULL
 
+from .context import Context
 from .project_config import ProjectConfig
 from .report_struct import Report
 from .constants import JSON_REPORT_FILE_NAME
-from .utils import stream_to_cli
+from .utils import make_streaming_function
+from .pipeline import Pipeline
+from .env import Env
 
 
 def review_subject_is_index(what):
@@ -51,6 +56,16 @@ def is_binary_file(repo: Repo, file_path: str) -> bool:
         return True  # Conservatively treat errors as binary to avoid issues
 
 
+def commit_in_branch(repo: Repo, commit: Commit, target_branch: str) -> bool:
+    try:
+        # exit code 0 if commit is ancestor of branch
+        repo.git.merge_base('--is-ancestor', commit.hexsha, target_branch)
+        return True
+    except GitCommandError:
+        pass
+    return False
+
+
 def get_diff(
     repo: Repo = None,
     what: str = None,
@@ -76,12 +91,75 @@ def get_diff(
         else:
             current_ref = what
         merge_base = repo.merge_base(current_ref or repo.active_branch.name, against)[0]
-        against = merge_base.hexsha
         logging.info(
-            f"Using merge base: {mc.ui.cyan(merge_base.hexsha[:8])} ({merge_base.summary})"
+            f"Merge base({ui.green(current_ref)},{ui.yellow(against)})"
+            f" --> {ui.cyan(merge_base.hexsha)}"
         )
+        # if branch is already an ancestor of "against", merge_base == branch ⇒ it’s been merged
+        if merge_base.hexsha == repo.commit(current_ref or repo.active_branch.name).hexsha:
+            # @todo: check case: reviewing working copy index in main branch #103
+            logging.info(
+                f"Branch is already merged. ({ui.green(current_ref)} vs {ui.yellow(against)})"
+            )
+            merge_sha = repo.git.log(
+                '--merges',
+                '--ancestry-path',
+                f'{current_ref}..{against}',
+                '-n',
+                '1',
+                '--pretty=format:%H'
+            ).strip()
+            if merge_sha:
+                logging.info(f"Merge commit is {ui.cyan(merge_sha)}")
+                merge_commit = repo.commit(merge_sha)
+
+                other_merge_parent = None
+                for parent in merge_commit.parents:
+                    logging.info(f"Checking merge parent: {parent.hexsha[:8]}")
+                    if parent.hexsha == merge_base.hexsha:
+                        logging.info(f"merge parent is {ui.cyan(parent.hexsha[:8])}, skipping")
+                        continue
+                    if not commit_in_branch(repo, parent, against):
+                        logging.warning(f"merge parent is not in {against}, skipping")
+                        continue
+                    logging.info(f"Found other merge parent: {ui.cyan(parent.hexsha[:8])}")
+                    other_merge_parent = parent
+                    break
+                if other_merge_parent:
+                    first_common_ancestor = repo.merge_base(other_merge_parent, merge_base)[0]
+                    # for gito remote (feature_branch vs origin/main)
+                    # the same merge base appears in first_common_ancestor again
+                    if first_common_ancestor.hexsha == merge_base.hexsha:
+                        if merge_base.parents:
+                            first_common_ancestor = repo.merge_base(
+                                other_merge_parent, merge_base.parents[0]
+                            )[0]
+                        else:
+                            logging.error(
+                                "merge_base has no parents, "
+                                "using merge_base as first_common_ancestor"
+                            )
+                    logging.info(
+                        f"{what} will be compared to "
+                        f"first common ancestor of {what} and {against}: "
+                        f"{ui.cyan(first_common_ancestor.hexsha[:8])}"
+                    )
+                    against = first_common_ancestor.hexsha
+                else:
+                    logging.error(f"Can't find other merge parent for {merge_sha}")
+            else:
+                logging.error(
+                    f"No merge‐commit found for {current_ref!r}→{against!r}; "
+                    "falling back to merge‐base diff"
+                )
+        else:
+            # normal case: branch not yet merged
+            against = merge_base.hexsha
+            logging.info(
+                f"Using merge base: {ui.cyan(merge_base.hexsha[:8])} ({merge_base.summary})"
+            )
     logging.info(
-        f"Making diff: {mc.ui.green(what or 'INDEX')} vs {mc.ui.yellow(against)}"
+        f"Making diff: {ui.green(what or 'INDEX')} vs {ui.yellow(against)}"
     )
     diff_content = repo.git.diff(against, what)
     diff = PatchSet.from_string(diff_content)
@@ -145,16 +223,17 @@ def file_lines(repo: Repo, file: str, max_tokens: int = None, use_local_files: b
     return "".join(lines)
 
 
-def make_cr_summary(config: ProjectConfig, report: Report, diff, **kwargs) -> str:
+def make_cr_summary(ctx: Context, **kwargs) -> str:
     return (
         mc.prompt(
-            config.summary_prompt,
-            diff=mc.tokenizing.fit_to_token_size(diff, config.max_code_tokens)[0],
-            issues=report.issues,
-            **config.prompt_vars,
+            ctx.config.summary_prompt,
+            diff=mc.tokenizing.fit_to_token_size(ctx.diff, ctx.config.max_code_tokens)[0],
+            issues=ctx.report.issues,
+            pipeline_out=ctx.pipeline_out,
+            **ctx.config.prompt_vars,
             **kwargs,
         ).to_llm()
-        if config.summary_prompt
+        if ctx.config.summary_prompt
         else ""
     )
 
@@ -197,6 +276,41 @@ def _prepare(
     return repo, cfg, diff, lines
 
 
+def get_affected_code_block(repo: Repo, file: str, start_line: int, end_line: int) -> str | None:
+    if not start_line or not end_line:
+        return None
+    try:
+        if isinstance(start_line, str):
+            start_line = int(start_line)
+        if isinstance(end_line, str):
+            end_line = int(end_line)
+        lines = file_lines(repo, file, max_tokens=None, use_local_files=True)
+        if lines:
+            lines = [""] + lines.splitlines()
+            return "\n".join(
+                lines[start_line: end_line + 1]
+            )
+    except Exception as e:
+        logging.error(
+            f"Error getting affected code block for {file} from {start_line} to {end_line}: {e}"
+        )
+    return None
+
+
+def provide_affected_code_blocks(issues: dict, repo: Repo):
+    for file, file_issues in issues.items():
+        for issue in file_issues:
+            for i in issue.get("affected_lines", []):
+                file_name = i.get("file", issue.get("file", file))
+                if block := get_affected_code_block(
+                    repo,
+                    file_name,
+                    i.get("start_line"),
+                    i.get("end_line")
+                ):
+                    i["affected_code"] = block
+
+
 async def review(
     repo: Repo = None,
     what: str = None,
@@ -226,24 +340,16 @@ async def review(
         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]
-                    )
+    provide_affected_code_blocks(issues, repo)
     exec(cfg.post_process, {"mc": mc, **locals()})
     out_folder = Path(out_folder or repo.working_tree_dir)
     out_folder.mkdir(parents=True, exist_ok=True)
     report = Report(issues=issues, number_of_processed_files=len(diff))
-    ctx = dict(
+    ctx = Context(
         report=report,
         config=cfg,
         diff=diff,
         repo=repo,
-        pipeline_out={},
     )
     if cfg.pipeline_steps:
         pipe = Pipeline(
@@ -254,7 +360,7 @@ async def review(
     else:
         logging.info("No pipeline steps defined, skipping pipeline execution")
 
-    report.summary = make_cr_summary(**ctx)
+    report.summary = make_cr_summary(ctx)
     report.save(file_name=out_folder / JSON_REPORT_FILE_NAME)
     report_text = report.render(cfg, Report.Format.MARKDOWN)
     text_report_path = out_folder / "code-review-report.md"
@@ -269,20 +375,41 @@ def answer(
     against: str = None,
     filters: str | list[str] = "",
     use_merge_base: bool = True,
+    use_pipeline: bool = True,
+    prompt_file: str = None,
 ) -> str | None:
     try:
-        repo, cfg, diff, lines = _prepare(
+        repo, config, diff, lines = _prepare(
             repo=repo, what=what, against=against, filters=filters, use_merge_base=use_merge_base
         )
     except NoChangesInContextError:
         logging.error("No changes to review")
         return
-    response = mc.llm(mc.prompt(
-        cfg.answer_prompt,
-        question=question,
+
+    ctx = Context(
+        repo=repo,
         diff=diff,
-        all_file_lines=lines,
-        **cfg.prompt_vars,
-        callback=stream_to_cli
-    ))
+        config=config,
+        report=Report()
+    )
+    if use_pipeline:
+        pipe = Pipeline(
+            ctx=ctx,
+            steps=config.pipeline_steps
+        )
+        pipe.run()
+    if prompt_file:
+        prompt_func = partial(mc.tpl, prompt_file)
+    else:
+        prompt_func = partial(mc.prompt, config.answer_prompt)
+    response = mc.llm(
+        prompt_func(
+            question=question,
+            diff=diff,
+            all_file_lines=lines,
+            pipeline_out=ctx.pipeline_out,
+            **config.prompt_vars,
+        ),
+        callback=make_streaming_function() if Env.verbosity == 0 else None,
+    )
     return response

gito/env.py

@@ -0,0 +1,3 @@
+class Env:
+    logging_level: int = 1
+    verbosity: int = 1