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

gito/pipeline.py

@@ -0,0 +1,82 @@
+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)
+    enabled: bool = field(default=True)
+
+    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)
+    verbose: bool = False
+
+    @property
+    def enabled_steps(self):
+        return {
+            k: v for k, v in self.steps.items() if v.enabled
+        }
+
+    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.enabled_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 self.verbose and step_output:
+                        logging.info(
+                            f"Pipeline step {step_name} output: {repr(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"]

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

@@ -1,119 +1,73 @@
-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)
+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)