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

gito/pipeline.py

@@ -1,70 +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)
-
-    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"]
+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

@@ -1,83 +1,57 @@
-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)
-    )
+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,71 +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 = ""
-    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)
+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)