ai-cr 2.0.0.dev1__tar.gz → 2.0.0.dev2__tar.gz

{ai_cr-2.0.0.dev1 → ai_cr-2.0.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ai-cr
-Version: 2.0.0.dev1
+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
@@ -18,7 +18,9 @@ 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
@@ -62,7 +64,7 @@ Get consistent, thorough code reviews in seconds—no waiting for human availabi
 
 ### 1. Review Pull Requests via GitHub Actions
 
-Create a `.github/workflows/gito.yml` file:
+Create a `.github/workflows/gito-code-review.yml` file:
 
 ```yaml
 name: "Gito: AI Code Review"

{ai_cr-2.0.0.dev1 → ai_cr-2.0.0.dev2}/README.md

@@ -35,7 +35,7 @@ Get consistent, thorough code reviews in seconds—no waiting for human availabi
 
 ### 1. Review Pull Requests via GitHub Actions
 
-Create a `.github/workflows/gito.yml` file:
+Create a `.github/workflows/gito-code-review.yml` file:
 
 ```yaml
 name: "Gito: AI Code Review"

{ai_cr-2.0.0.dev1 → ai_cr-2.0.0.dev2}/gito/cli.py

@@ -18,7 +18,7 @@ from .project_config import ProjectConfig
 from .utils import no_subcommand, parse_refs_pair
 
 # Import fix command to register it
-from .commands import fix  # noqa
+from .commands import fix, gh_comment  # noqa
 
 
 app_no_subcommand = typer.Typer(pretty_exceptions_show_locals=False)
@@ -40,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]:
@@ -104,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(),

{ai_cr-2.0.0.dev1 → ai_cr-2.0.0.dev2}/gito/commands/fix.py

@@ -6,12 +6,13 @@ 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
+from ..report_struct import Report, Issue
 
 
 @app.command(help="Fix an issue from the code review report")
@@ -26,7 +27,9 @@ def fix(
     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.
     """
@@ -39,7 +42,7 @@ def fix(
         raise typer.Exit(code=1)
 
     # Find the issue by number
-    issue = None
+    issue: Optional[Issue] = None
     for file_issues in report.issues.values():
         for i in file_issues:
             if i.id == issue_number:
@@ -122,3 +125,33 @@ def fix(
             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()

ai_cr-2.0.0.dev2/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 []

{ai_cr-2.0.0.dev1 → ai_cr-2.0.0.dev2}/gito/config.toml

@@ -1,3 +1,8 @@
+# :class: gito.project_config.ProjectConfig
+
+# 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"]
 report_template_md = """
 <h2><a href="https://github.com/Nayjest/Gito"><img src="https://raw.githubusercontent.com/Nayjest/Gito/main/press-kit/logo/gito-bot-1_64top.png" align="left" width=64 height=50></a>I've Reviewed the Code</h2>
 
@@ -199,12 +204,37 @@ Note: Awards should only be given to authors of initial codebase changes, not to
 --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.
+
+--Associated Issue--
+# {{ pipeline_out.associated_issue.title }}
+{{ pipeline_out.associated_issue.description }}
+URL: {{ pipeline_out.associated_issue.url }}
+---
+
+Examples:
+
+In case if the implementation delivers what was requested:
+```
+✅  Implementation Satisfies [<ISSUE_KEY>](<ISSUE_URL>).
+```
+In case of any critical concerns:
+```
+⚠️  <Your concern 1 here>.
+⚠️  <Your concern 2 here>.
+```
+--------
+{% endif -%}
 - Your response will be parsed programmatically, so do not include any additional text.
 - Do not include the issues by itself to the summary, they are already provided in the context.
 - Use Markdown formatting in your response.
 {{ summary_requirements -}}
 """
-
+[pipeline_steps.jira]
+call="gito.pipeline_steps.jira.fetch_associated_issue"
+envs=["local","gh-action"]
 [prompt_vars]
 self_id = """
 You are a subsystem of an AI-powered software platform, specifically tasked with performing expert code reviews.

{ai_cr-2.0.0.dev1 → ai_cr-2.0.0.dev2}/gito/core.py

@@ -6,6 +6,7 @@ from pathlib import Path
 
 import microcore as mc
 from git import Repo
+from gito.pipeline import Pipeline
 from unidiff import PatchSet, PatchedFile
 from unidiff.constants import DEV_NULL
 
@@ -143,15 +144,16 @@ def file_lines(repo: Repo, file: str, max_tokens: int = None, use_local_files: b
     return "".join(lines)
 
 
-def make_cr_summary(cfg: ProjectConfig, report: Report, diff):
+def make_cr_summary(config: ProjectConfig, report: Report, diff, **kwargs) -> str:
     return (
         mc.prompt(
-            cfg.summary_prompt,
-            diff=mc.tokenizing.fit_to_token_size(diff, cfg.max_code_tokens)[0],
+            config.summary_prompt,
+            diff=mc.tokenizing.fit_to_token_size(diff, config.max_code_tokens)[0],
             issues=report.issues,
-            **cfg.prompt_vars,
+            **config.prompt_vars,
+            **kwargs,
         ).to_llm()
-        if cfg.summary_prompt
+        if config.summary_prompt
         else ""
     )
 
@@ -213,7 +215,23 @@ async def review(
     exec(cfg.post_process, {"mc": mc, **locals()})
     out_folder.mkdir(parents=True, exist_ok=True)
     report = Report(issues=issues, number_of_processed_files=len(diff))
-    report.summary = make_cr_summary(cfg, report, diff)
+    ctx = dict(
+        report=report,
+        config=cfg,
+        diff=diff,
+        repo=repo,
+        pipeline_out={},
+    )
+    if cfg.pipeline_steps:
+        pipe = Pipeline(
+            ctx=ctx,
+            steps=cfg.pipeline_steps
+        )
+        pipe.run()
+    else:
+        logging.info("No pipeline steps defined, skipping pipeline execution")
+
+    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"

ai_cr-2.0.0.dev2/gito/issue_trackers.py

@@ -0,0 +1,15 @@
+import re
+from dataclasses import dataclass, field
+
+
+def extract_issue_key(branch_name: str, min_len=2, max_len=10) -> str | None:
+    pattern = fr"\b[A-Z][A-Z0-9]{{{min_len - 1},{max_len - 1}}}-\d+\b"
+    match = re.search(pattern, branch_name)
+    return match.group(0) if match else None
+
+
+@dataclass
+class IssueTrackerIssue:
+    title: str = field(default="")
+    description: str = field(default="")
+    url: str = field(default="")

ai_cr-2.0.0.dev2/gito/pipeline.py

@@ -0,0 +1,70 @@
+import logging
+from enum import StrEnum
+from dataclasses import dataclass, field
+
+from gito.utils import is_running_in_github_action
+from microcore import ui
+from microcore.utils import resolve_callable
+
+
+class PipelineEnv(StrEnum):
+    LOCAL = "local"
+    GH_ACTION = "gh-action"
+
+    @staticmethod
+    def all():
+        return [PipelineEnv.LOCAL, PipelineEnv.GH_ACTION]
+
+    @staticmethod
+    def current():
+        return (
+            PipelineEnv.GH_ACTION
+            if is_running_in_github_action()
+            else PipelineEnv.LOCAL
+        )
+
+
+@dataclass
+class PipelineStep:
+    call: str
+    envs: list[PipelineEnv] = field(default_factory=PipelineEnv.all)
+
+    def get_callable(self):
+        """
+        Resolve the callable from the string representation.
+        """
+        return resolve_callable(self.call)
+
+    def run(self, *args, **kwargs):
+        return self.get_callable()(*args, **kwargs)
+
+
+@dataclass
+class Pipeline:
+    ctx: dict = field(default_factory=dict)
+    steps: dict[str, PipelineStep] = field(default_factory=dict)
+
+    def run(self, *args, **kwargs):
+        cur_env = PipelineEnv.current()
+        logging.info("Running pipeline... [env: %s]", ui.yellow(cur_env))
+        self.ctx["pipeline_out"] = self.ctx.get("pipeline_out", {})
+        for step_name, step in self.steps.items():
+            if cur_env in step.envs:
+                logging.info(f"Running pipeline step: {step_name}")
+                try:
+                    step_output = step.run(*args, **kwargs, **self.ctx)
+                    if isinstance(step_output, dict):
+                        self.ctx["pipeline_out"].update(step_output)
+                    self.ctx["pipeline_out"][step_name] = step_output
+                    if not step_output:
+                        logging.warning(
+                            f'Pipeline step "{step_name}" returned {repr(step_output)}.'
+                        )
+                except Exception as e:
+                    logging.error(f'Error in pipeline step "{step_name}": {e}')
+            else:
+                logging.info(
+                    f"Skipping pipeline step: {step_name}"
+                    f" [env: {ui.yellow(cur_env)} not in {step.envs}]"
+                )
+        return self.ctx["pipeline_out"]

ai_cr-2.0.0.dev2/gito/pipeline_steps/jira.py

@@ -0,0 +1,83 @@
+import logging
+import os
+
+import git
+from jira import JIRA
+
+from gito.issue_trackers import extract_issue_key, IssueTrackerIssue
+from gito.utils import is_running_in_github_action
+
+
+def fetch_issue(issue_key, jira_url, username, api_token) -> IssueTrackerIssue | None:
+    try:
+        jira = JIRA(jira_url, basic_auth=(username, api_token))
+        issue = jira.issue(issue_key)
+        return IssueTrackerIssue(
+            title=issue.fields.summary,
+            description=issue.fields.description or "",
+            url=f"{jira_url.rstrip('/')}/browse/{issue_key}"
+        )
+    except Exception as e:
+        logging.error(f"Failed to fetch Jira issue {issue_key}: {e}")
+        return None
+
+
+def get_branch(repo: git.Repo):
+    if is_running_in_github_action():
+        branch_name = os.getenv('GITHUB_HEAD_REF')
+        if branch_name:
+            return branch_name
+
+        github_ref = os.getenv('GITHUB_REF', '')
+        if github_ref.startswith('refs/heads/'):
+            return github_ref.replace('refs/heads/', '')
+    try:
+        branch_name = repo.active_branch.name
+        return branch_name
+    except Exception as e:  # @todo: specify more precise exception
+        logging.error("Could not determine the active branch name: %s", e)
+        return None
+
+
+def fetch_associated_issue(
+    repo: git.Repo,
+    jira_url=None,
+    jira_username=None,
+    jira_api_token=None,
+    **kwargs
+):
+    """
+    Pipeline step to fetch a Jira issue based on the current branch name.
+    """
+    branch_name = get_branch(repo)
+    if not branch_name:
+        logging.error("No active branch found in the repository, cannot determine Jira issue key.")
+        return None
+
+    if not (issue_key := extract_issue_key(branch_name)):
+        logging.error(f"No Jira issue key found in branch name: {branch_name}")
+        return None
+
+    jira_url = jira_url or os.getenv("JIRA_URL")
+    jira_username = (
+        jira_username
+        or os.getenv("JIRA_USERNAME")
+        or os.getenv("JIRA_USER")
+        or os.getenv("JIRA_EMAIL")
+    )
+    jira_token = (
+        jira_api_token
+        or os.getenv("JIRA_API_TOKEN")
+        or os.getenv("JIRA_API_KEY")
+        or os.getenv("JIRA_TOKEN")
+    )
+    try:
+        assert jira_url, "JIRA_URL is not set"
+        assert jira_username, "JIRA_USERNAME is not set"
+        assert jira_token, "JIRA_API_TOKEN is not set"
+    except AssertionError as e:
+        logging.error(f"Jira configuration error: {e}")
+        return None
+    return dict(
+        associated_issue=fetch_issue(issue_key, jira_url, jira_username, jira_token)
+    )

ai_cr-2.0.0.dev2/gito/project_config.py

@@ -0,0 +1,71 @@
+import logging
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import microcore as mc
+from gito.utils import detect_github_env
+from microcore import ui
+from git import Repo
+
+from .constants import PROJECT_CONFIG_BUNDLED_DEFAULTS_FILE, PROJECT_CONFIG_FILE_PATH
+from .pipeline import PipelineStep
+
+
+@dataclass
+class ProjectConfig:
+    prompt: str = ""
+    summary_prompt: str = ""
+    report_template_md: str = ""
+    """Markdown report template"""
+    report_template_cli: str = ""
+    """Report template for CLI output"""
+    post_process: str = ""
+    retries: int = 3
+    """LLM retries for one request"""
+    max_code_tokens: int = 32000
+    prompt_vars: dict = field(default_factory=dict)
+    mention_triggers: list[str] = field(default_factory=list)
+    """
+    Defines the keyword or mention tag that triggers bot actions
+    when referenced in code review comments.
+    """
+    pipeline_steps: dict[str, dict | PipelineStep] = field(default_factory=dict)
+
+    def __post_init__(self):
+        self.pipeline_steps = {
+            k: PipelineStep(**v) if isinstance(v, dict) else v
+            for k, v in self.pipeline_steps.items()
+        }
+
+    @staticmethod
+    def _read_bundled_defaults() -> dict:
+        with open(PROJECT_CONFIG_BUNDLED_DEFAULTS_FILE, "rb") as f:
+            config = tomllib.load(f)
+        return config
+
+    @staticmethod
+    def load_for_repo(repo: Repo):
+        return ProjectConfig.load(Path(repo.working_tree_dir) / PROJECT_CONFIG_FILE_PATH)
+
+    @staticmethod
+    def load(config_path: str | Path | None = None) -> "ProjectConfig":
+        config = ProjectConfig._read_bundled_defaults()
+        github_env = detect_github_env()
+        config["prompt_vars"] |= github_env | dict(github_env=github_env)
+
+        config_path = Path(config_path or PROJECT_CONFIG_FILE_PATH)
+        if config_path.exists():
+            logging.info(
+                f"Loading project-specific configuration from {mc.utils.file_link(config_path)}...")
+            default_prompt_vars = config["prompt_vars"]
+            with open(config_path, "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"No project config found at {ui.blue(config_path)}, using defaults"
+            )
+
+        return ProjectConfig(**config)

{ai_cr-2.0.0.dev1 → ai_cr-2.0.0.dev2}/gito/report_struct.py

@@ -63,12 +63,13 @@ class Report:
         MARKDOWN = "md"
         CLI = "cli"
 
-    issues: dict = field(default_factory=dict)
+    issues: dict[str, list[Issue]] = field(default_factory=dict)
     summary: str = field(default="")
     number_of_processed_files: int = field(default=0)
     total_issues: int = field(init=False)
     created_at: str = field(default_factory=lambda: datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
     model: str = field(default_factory=lambda: mc.config().MODEL)
+    pipeline_out: dict = field(default_factory=dict)
 
     @property
     def plain_issues(self):

{ai_cr-2.0.0.dev1 → ai_cr-2.0.0.dev2}/gito/utils.py

@@ -1,8 +1,11 @@
+import re
 import sys
 import os
 from pathlib import Path
-import typer
 
+import typer
+import git
+from git import Repo
 
 _EXT_TO_HINT: dict[str, str] = {
     # scripting & languages
@@ -130,3 +133,82 @@ def block_wrap_lr(text: str, left: str = "", right: str = "", max_rwrap: int = 6
             ln += ' ' * (ml - len(line)) + right
         wrapped_lines.append(ln)
     return "\n".join(wrapped_lines)
+
+
+def extract_gh_owner_repo(repo: git.Repo) -> tuple[str, str]:
+    """
+    Extracts the GitHub owner and repository name.
+
+    Returns:
+        tuple[str, str]: A tuple containing the owner and repository name.
+    """
+    remote_url = repo.remotes.origin.url
+    if remote_url.startswith('git@github.com:'):
+        # SSH format: git@github.com:owner/repo.git
+        repo_path = remote_url.split(':')[1].replace('.git', '')
+    elif remote_url.startswith('https://github.com/'):
+        # HTTPS format: https://github.com/owner/repo.git
+        repo_path = remote_url.replace('https://github.com/', '').replace('.git', '')
+    else:
+        raise ValueError("Unsupported remote URL format")
+    owner, repo_name = repo_path.split('/')
+    return owner, repo_name
+
+
+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.
+    """
+    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:
+        git_repo = None
+        try:
+            git_repo = Repo(".", search_parent_directories=True)
+            origin = git_repo.remotes.origin.url
+            # e.g. git@github.com:Nayjest/ai-code-review.git -> Nayjest/ai-code-review
+            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_repo.head.commit.hexsha
+            d["github_branch"] = (
+                git_repo.active_branch.name if hasattr(git_repo, "active_branch") else ""
+            )
+        except Exception:
+            pass
+        finally:
+            if git_repo:
+                try:
+                    git_repo.close()
+                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

{ai_cr-2.0.0.dev1 → ai_cr-2.0.0.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ai-cr"
-version = "2.0.0-dev1"
+version = "2.0.0-dev2"
 description = "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."
 authors = ["Nayjest <mail@vitaliy.in>"]
 readme = "README.md"
@@ -27,6 +27,8 @@ unidiff = "^0.7.5"
 google-generativeai = "^0.8.5"
 anthropic = "^0.52.2"
 typer = "^0.16.0"
+ghapi = "~=1.0.6"
+jira = "^3.8.0"
 
 [tool.poetry.group.dev.dependencies]
 flake8 = "*"

ai_cr-2.0.0.dev1/gito/project_config.py

@@ -1,119 +0,0 @@
-import re
-import logging
-import tomllib
-from dataclasses import dataclass, field
-from pathlib import Path
-
-import microcore as mc
-from microcore import ui
-from git import Repo
-
-from .constants import PROJECT_CONFIG_BUNDLED_DEFAULTS_FILE, PROJECT_CONFIG_FILE_PATH
-
-
-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:
-        git_repo = None
-        try:
-            git_repo = Repo(".", search_parent_directories=True)
-            origin = git_repo.remotes.origin.url
-            # e.g. git@github.com:Nayjest/ai-code-review.git -> Nayjest/ai-code-review
-            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_repo.head.commit.hexsha
-            d["github_branch"] = (
-                git_repo.active_branch.name if hasattr(git_repo, "active_branch") else ""
-            )
-        except Exception:
-            pass
-        finally:
-            if git_repo:
-                try:
-                    git_repo.close()
-                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"""
-    report_template_cli: str = ""
-    """Report template for CLI output"""
-    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 _read_bundled_defaults() -> dict:
-        with open(PROJECT_CONFIG_BUNDLED_DEFAULTS_FILE, "rb") as f:
-            config = tomllib.load(f)
-        return config
-
-    @staticmethod
-    def load_for_repo(repo: Repo):
-        return ProjectConfig.load(Path(repo.working_tree_dir) / PROJECT_CONFIG_FILE_PATH)
-
-    @staticmethod
-    def load(config_path: str | Path | None = None) -> "ProjectConfig":
-        config = ProjectConfig._read_bundled_defaults()
-        github_env = _detect_github_env()
-        config["prompt_vars"] |= github_env | dict(github_env=github_env)
-
-        config_path = Path(config_path or PROJECT_CONFIG_FILE_PATH)
-        if config_path.exists():
-            logging.info(
-                f"Loading project-specific configuration from {mc.utils.file_link(config_path)}...")
-            default_prompt_vars = config["prompt_vars"]
-            with open(config_path, "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"No project config found at {ui.blue(config_path)}, using defaults"
-            )
-
-        return ProjectConfig(**config)