ai-cr 1.0.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

gito/pipeline_steps/jira.py

@@ -0,0 +1,57 @@
+import logging
+import os
+
+import git
+from jira import JIRA
+
+from gito.issue_trackers import IssueTrackerIssue, resolve_issue_key
+
+
+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 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.
+    """
+    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
+    issue_key = resolve_issue_key(repo)
+    return dict(
+        associated_issue=fetch_issue(issue_key, jira_url, jira_username, jira_token)
+    ) if issue_key else None

gito/pipeline_steps/linear.py

@@ -0,0 +1,84 @@
+import logging
+import os
+import requests
+
+import git
+
+from gito.issue_trackers import IssueTrackerIssue, resolve_issue_key
+
+
+def fetch_issue(issue_key, api_key) -> IssueTrackerIssue | None:
+    """
+    Fetch a Linear issue using GraphQL API.
+    """
+    try:
+        url = "https://api.linear.app/graphql"
+        headers = {
+            "Authorization": f"{api_key}",
+            "Content-Type": "application/json"
+        }
+
+        query = """
+            query Issues($teamKey: String!, $issueNumber: Float) {
+                issues(filter: {team: {key: {eq: $teamKey}}, number: {eq: $issueNumber}}) {
+                    nodes {
+                        id
+                        identifier
+                        title
+                        description
+                        url
+                    }
+                }
+            }
+        """
+        team_key, issue_number = issue_key.split("-")
+        response = requests.post(
+            url,
+            json={
+                "query": query,
+                "variables":  {'teamKey': team_key, 'issueNumber': int(issue_number)}
+            },
+            headers=headers
+        )
+        response.raise_for_status()
+        data = response.json()
+
+        if "errors" in data:
+            logging.error(f"Linear API error: {data['errors']}")
+            return None
+
+        nodes = data.get("data", {}).get("issues", {}).get("nodes", [])
+        if not nodes:
+            logging.error(f"Linear issue {issue_key} not found")
+            return None
+
+        issue = nodes[0]
+        return IssueTrackerIssue(
+            title=issue["title"],
+            description=issue.get("description") or "",
+            url=issue["url"]
+        )
+
+    except requests.HTTPError as e:
+        logging.error(f"Failed to fetch Linear issue {issue_key}: {e}")
+        logging.error(f"Response body: {response.text}")
+        return None
+
+
+def fetch_associated_issue(
+    repo: git.Repo,
+    api_key=None,
+    **kwargs
+):
+    """
+    Pipeline step to fetch a Linear issue based on the current branch name.
+    """
+    api_key = api_key or os.getenv("LINEAR_API_KEY")
+    if not api_key:
+        logging.error("LINEAR_API_KEY environment variable is not set")
+        return
+
+    issue_key = resolve_issue_key(repo)
+    return dict(
+        associated_issue=fetch_issue(issue_key, api_key)
+    ) if issue_key else None

gito/project_config.py

@@ -0,0 +1,73 @@
+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 = ""
+    answer_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)
+    answer_github_comments: bool = field(default=True)
+    """
+    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_code_review → gito}/report_struct.py

@@ -1,108 +1,134 @@
-import json
-import logging
-from dataclasses import dataclass, field, asdict
-from datetime import datetime
-from enum import StrEnum
-
-import microcore as mc
-
-from .constants import JSON_REPORT_FILE_NAME
-from .project_config import ProjectConfig
-from .utils import syntax_hint
-
-
-@dataclass
-class Issue:
-    @dataclass
-    class AffectedCode:
-        start_line: int = field()
-        end_line: int | None = field(default=None)
-        file: str = field(default="")
-        proposal: str = field(default="")
-        affected_code: str = field(default="")
-
-        @property
-        def syntax_hint(self) -> str:
-            return syntax_hint(self.file)
-
-    id: str = field()
-    title: str = field()
-    details: str = field(default="")
-    severity: int | None = field(default=None)
-    confidence: int | None = field(default=None)
-    tags: list[str] = field(default_factory=list)
-    file: str = field(default="")
-    affected_lines: list[AffectedCode] = field(default_factory=list)
-
-    def __post_init__(self):
-        self.affected_lines = [
-            Issue.AffectedCode(**dict(file=self.file) | i)
-            for i in self.affected_lines
-        ]
-
-    def github_code_link(self, github_env: dict) -> str:
-        url = (
-            f"https://github.com/{github_env['github_repo']}"
-            f"/blob/{github_env['github_pr_sha_or_branch']}"
-            f"/{self.file}"
-        )
-        if self.affected_lines:
-            url += f"#L{self.affected_lines[0].start_line}"
-            if self.affected_lines[0].end_line:
-                url += f"-L{self.affected_lines[0].end_line}"
-        return url
-
-
-@dataclass
-class Report:
-    class Format(StrEnum):
-        MARKDOWN = "md"
-
-    issues: dict = 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)
-
-    @property
-    def plain_issues(self):
-        return [
-            issue
-            for file, issues in self.issues.items()
-            for issue in issues
-        ]
-
-    def __post_init__(self):
-        issue_id: int = 0
-        for file in self.issues.keys():
-            self.issues[file] = [
-                Issue(
-                    **{
-                        "id": (issue_id := issue_id + 1),
-                        "file": file,
-                    } | issue
-                )
-                for issue in self.issues[file]
-            ]
-        self.total_issues = issue_id
-
-    def save(self, file_name: str = ""):
-        file_name = file_name or JSON_REPORT_FILE_NAME
-        with open(file_name, "w") as f:
-            json.dump(asdict(self), f, indent=4)
-        logging.info(f"Report saved to {mc.utils.file_link(file_name)}")
-
-    @staticmethod
-    def load(file_name: str = ""):
-        with open(file_name or JSON_REPORT_FILE_NAME, "r") as f:
-            data = json.load(f)
-        data.pop("total_issues", None)
-        return Report(**data)
-
-    def render(
-        self, cfg: ProjectConfig = None, format: Format = Format.MARKDOWN
-    ) -> str:
-        cfg = cfg or ProjectConfig.load()
-        template = getattr(cfg, f"report_template_{format}")
-        return mc.prompt(template, report=self, **cfg.prompt_vars)
+import json
+import logging
+from dataclasses import dataclass, field, asdict
+from datetime import datetime
+from enum import StrEnum
+from pathlib import Path
+
+import microcore as mc
+from colorama import Fore, Style, Back
+from microcore.utils import file_link
+import textwrap
+
+from .constants import JSON_REPORT_FILE_NAME, HTML_TEXT_ICON
+from .project_config import ProjectConfig
+from .utils import syntax_hint, block_wrap_lr, max_line_len
+
+
+@dataclass
+class Issue:
+    @dataclass
+    class AffectedCode:
+        start_line: int = field()
+        end_line: int | None = field(default=None)
+        file: str = field(default="")
+        proposal: str = field(default="")
+        affected_code: str = field(default="")
+
+        @property
+        def syntax_hint(self) -> str:
+            return syntax_hint(self.file)
+
+    id: str = field()
+    title: str = field()
+    details: str = field(default="")
+    severity: int | None = field(default=None)
+    confidence: int | None = field(default=None)
+    tags: list[str] = field(default_factory=list)
+    file: str = field(default="")
+    affected_lines: list[AffectedCode] = field(default_factory=list)
+
+    def __post_init__(self):
+        self.affected_lines = [
+            Issue.AffectedCode(**dict(file=self.file) | i)
+            for i in self.affected_lines
+        ]
+
+    def github_code_link(self, github_env: dict) -> str:
+        url = (
+            f"https://github.com/{github_env['github_repo']}"
+            f"/blob/{github_env['github_pr_sha_or_branch']}"
+            f"/{self.file}"
+        )
+        if self.affected_lines:
+            url += f"#L{self.affected_lines[0].start_line}"
+            if self.affected_lines[0].end_line:
+                url += f"-L{self.affected_lines[0].end_line}"
+        return url
+
+
+@dataclass
+class Report:
+    class Format(StrEnum):
+        MARKDOWN = "md"
+        CLI = "cli"
+
+    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):
+        return [
+            issue
+            for file, issues in self.issues.items()
+            for issue in issues
+        ]
+
+    def __post_init__(self):
+        issue_id: int = 0
+        for file in self.issues.keys():
+            self.issues[file] = [
+                Issue(
+                    **{
+                        "id": (issue_id := issue_id + 1),
+                        "file": file,
+                    } | issue
+                )
+                for issue in self.issues[file]
+            ]
+        self.total_issues = issue_id
+
+    def save(self, file_name: str = ""):
+        file_name = file_name or JSON_REPORT_FILE_NAME
+        with open(file_name, "w") as f:
+            json.dump(asdict(self), f, indent=4)
+        logging.info(f"Report saved to {mc.utils.file_link(file_name)}")
+
+    @staticmethod
+    def load(file_name: str | Path = ""):
+        with open(file_name or JSON_REPORT_FILE_NAME, "r") as f:
+            data = json.load(f)
+        data.pop("total_issues", None)
+        return Report(**data)
+
+    def render(
+        self,
+        config: ProjectConfig = None,
+        report_format: Format = Format.MARKDOWN,
+    ) -> str:
+        config = config or ProjectConfig.load()
+        template = getattr(config, f"report_template_{report_format}")
+        return mc.prompt(
+            template,
+            report=self,
+            ui=mc.ui,
+            Fore=Fore,
+            Style=Style,
+            Back=Back,
+            file_link=file_link,
+            textwrap=textwrap,
+            block_wrap_lr=block_wrap_lr,
+            max_line_len=max_line_len,
+            HTML_TEXT_ICON=HTML_TEXT_ICON,
+            **config.prompt_vars
+        )
+
+    def to_cli(self, report_format=Format.CLI):
+        output = self.render(report_format=report_format)
+        print("")
+        print(output)

gito/utils.py

@@ -0,0 +1,226 @@
+import re
+import sys
+import os
+from pathlib import Path
+
+import typer
+import git
+from git import Repo
+from microcore import ui
+
+
+_EXT_TO_HINT: dict[str, str] = {
+    # scripting & languages
+    ".py": "python",
+    ".js": "javascript",
+    ".ts": "typescript",
+    ".java": "java",
+    ".c": "c",
+    ".cpp": "cpp",
+    ".cc": "cpp",
+    ".cxx": "cpp",
+    ".h": "cpp",
+    ".hpp": "cpp",
+    ".cs": "csharp",
+    ".rb": "ruby",
+    ".go": "go",
+    ".rs": "rust",
+    ".swift": "swift",
+    ".kt": "kotlin",
+    ".scala": "scala",
+    ".dart": "dart",
+    ".php": "php",
+    ".pl": "perl",
+    ".pm": "perl",
+    ".lua": "lua",
+    # web & markup
+    ".html": "html",
+    ".htm": "html",
+    ".css": "css",
+    ".scss": "scss",
+    ".less": "less",
+    ".json": "json",
+    ".xml": "xml",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".toml": "toml",
+    ".ini": "ini",
+    ".csv": "csv",
+    ".md": "markdown",
+    ".rst": "rest",
+    # shell & config
+    ".sh": "bash",
+    ".bash": "bash",
+    ".zsh": "bash",
+    ".fish": "bash",
+    ".ps1": "powershell",
+    ".dockerfile": "dockerfile",
+    # build & CI
+    ".makefile": "makefile",
+    ".mk": "makefile",
+    "CMakeLists.txt": "cmake",
+    "Dockerfile": "dockerfile",
+    ".gradle": "groovy",
+    ".travis.yml": "yaml",
+    # data & queries
+    ".sql": "sql",
+    ".graphql": "graphql",
+    ".proto": "protobuf",
+    ".yara": "yara",
+}
+
+
+def syntax_hint(file_path: str | Path) -> str:
+    """
+    Returns a syntax highlighting hint based on the file's extension or name.
+
+    This can be used to annotate code blocks for rendering with syntax highlighting,
+    e.g., using Markdown-style code blocks: ```<syntax_hint>\n<code>\n```.
+
+    Args:
+      file_path (str | Path): Path to the file.
+
+    Returns:
+      str: A syntax identifier suitable for code highlighting (e.g., 'python', 'json').
+    """
+    p = Path(file_path)
+    ext = p.suffix.lower()
+    if not ext:
+        name = p.name.lower()
+        if name == "dockerfile":
+            return "dockerfile"
+        return ""
+    return _EXT_TO_HINT.get(ext, ext.lstrip("."))
+
+
+def is_running_in_github_action():
+    return os.getenv("GITHUB_ACTIONS") == "true"
+
+
+def no_subcommand(app: typer.Typer) -> bool:
+    """
+    Checks if the current script is being invoked as a command in a target Typer application.
+    """
+    return not (
+        (first_arg := next((a for a in sys.argv[1:] if not a.startswith('-')), None))
+        and first_arg in (
+            cmd.name or cmd.callback.__name__.replace('_', '-')
+            for cmd in app.registered_commands
+        )
+        or '--help' in sys.argv
+    )
+
+
+def parse_refs_pair(refs: str) -> tuple[str | None, str | None]:
+    SEPARATOR = '..'
+    if not refs:
+        return None, None
+    if SEPARATOR not in refs:
+        return refs, None
+    what, against = refs.split(SEPARATOR, 1)
+    return what or None, against or None
+
+
+def max_line_len(text: str) -> int:
+    return max((len(line) for line in text.splitlines()), default=0)
+
+
+def block_wrap_lr(
+    text: str,
+    left: str = "",
+    right: str = "",
+    max_rwrap: int = 60,
+    min_wrap: int = 0,
+) -> str:
+    ml = max(max_line_len(text), min_wrap)
+    lines = text.splitlines()
+    wrapped_lines = []
+    for line in lines:
+        ln = left+line
+        if ml <= max_rwrap:
+            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
+
+
+def stream_to_cli(text):
+    print(ui.blue(text), end='')