feat(#93): lgtm can now optionally use issues from GitLab (#106)

Author: scastlara

pyproject.toml

@@ -126,6 +126,7 @@ mypy_path = "src"
 strict = true          # strict type checking.
 warn_no_return = false # allow functions without explicit return.
 pretty = true          # show error messages in a readable format.
+plugins = ['pydantic.mypy']
 
 [tool.twyn]
 allowlist = [

src/lgtm_ai/__main__.py

@@ -13,7 +13,7 @@
     get_summarizing_agent_with_settings,
 )
 from lgtm_ai.ai.schemas import AgentSettings, CommentCategory, SupportedAIModels, SupportedAIModelsList
-from lgtm_ai.base.schemas import IntOrNoLimit, OutputFormat, PRUrl
+from lgtm_ai.base.schemas import IntOrNoLimit, IssuesSource, OutputFormat, PRUrl
 from lgtm_ai.base.utils import git_source_supports_suggestions
 from lgtm_ai.config.constants import DEFAULT_INPUT_TOKEN_LIMIT
 from lgtm_ai.config.handler import ConfigHandler, PartialConfig
@@ -95,6 +95,21 @@ def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
 
 
 @entry_point.command()
+@click.option(
+    "--issues-url",
+    type=click.STRING,
+    help="The URL of the issues page to retrieve additional context from.",
+)
+@click.option(
+    "--issues-source",
+    type=click.Choice([source.value for source in IssuesSource]),
+    help="The platform of the issues page.",
+)
+@click.option(
+    "--issues-regex",
+    type=click.STRING,
+    help="Regex to extract issue ID from the PR title and description.",
+)
 @click.option(
     "--technologies",
     multiple=True,
@@ -123,6 +138,9 @@ def review(
     verbose: int,
     technologies: tuple[str, ...],
     categories: tuple[CommentCategory, ...],
+    issues_url: str | None,
+    issues_regex: str | None,
+    issues_source: IssuesSource | None,
 ) -> None:
     """Review a Pull Request using AI."""
     _set_logging_level(logger, verbose)
@@ -144,6 +162,9 @@ def review(
             silent=silent,
             ai_retries=ai_retries,
             ai_input_tokens_limit=ai_input_tokens_limit,
+            issues_url=issues_url,
+            issues_regex=issues_regex,
+            issues_source=issues_source,
         ),
         config_file=config,
     ).resolve_config()

src/lgtm_ai/ai/prompts.py

@@ -55,6 +55,7 @@ def _get_full_category_explanation() -> str:
         }}
         ```
 - `Context`, which consists on the contents of each of the changed files in the source (PR) branch or the target branch. This should help you to understand the context of the PR.
+- Optionally, `User Story` that the PR is implementing, which will consist of a title and a description. You must evaluate whether the PR is correctly implementing the user story (in its totality or partially).
 - Optionally, `Additional context` that the author of the PR has provided, which may contain a prompt (to give you a hint on what to use it for), and some content.
 
 You should make two types of comments:

src/lgtm_ai/base/schemas.py

@@ -11,6 +11,14 @@ class PRSource(StrEnum):
     gitlab = "gitlab"
 
 
+class IssuesSource(StrEnum):
+    gitlab = "gitlab"
+
+    @property
+    def is_git_platform(self) -> bool:
+        return self in {IssuesSource.gitlab}
+
+
 @dataclass(frozen=True, slots=True)
 class PRUrl:
     full_url: str

src/lgtm_ai/config/constants.py

@@ -2,3 +2,4 @@
 
 DEFAULT_AI_MODEL: SupportedAIModels = "gemini-2.0-flash"
 DEFAULT_INPUT_TOKEN_LIMIT = 500000
+DEFAULT_ISSUE_REGEX = r"(?:refs?|closes?)[:\s]*((?:#\d+)|(?:#?[A-Z]+-\d+))|(?:fix|feat|docs|style|refactor|perf|test|build|ci)\((?:#(\d+)|#?([A-Z]+-\d+))\)!?:"

src/lgtm_ai/config/exceptions.py

@@ -1,4 +1,5 @@
 from lgtm_ai.base.exceptions import LGTMException
+from pydantic import ValidationError
 from pydantic_core import ErrorDetails
 
 
@@ -18,8 +19,28 @@ def __str__(self) -> str:
         return self.message
 
     def _generate_message(self) -> str:
-        messages = [f"'{str(error['loc'][0])}': {error['msg']}" for error in self.errors]
+        messages = _extract_errors_from_validation_error(self.errors)
         return f"Invalid config file '{self.source}':\n" + "\n".join(messages)
 
 
+class InvalidOptionsError(LGTMException):
+    """Raised when options (no matter where they come from) are invalid."""
+
+    def __init__(self, err: ValidationError) -> None:
+        self.err = err
+        self.message = self._generate_message()
+
+    def __str__(self) -> str:
+        return self.message
+
+    def _generate_message(self) -> str:
+        messages = _extract_errors_from_validation_error(self.err)
+        return "Invalid options:\n" + "\n".join(messages)
+
+
 class MissingRequiredConfigError(LGTMException): ...
+
+
+def _extract_errors_from_validation_error(err: ValidationError | list[ErrorDetails]) -> list[str]:
+    errors = err.errors() if isinstance(err, ValidationError) else err
+    return [f"'{str(error['loc'][0])}': {error['msg']}" for error in errors]

src/lgtm_ai/config/handler.py

@@ -4,18 +4,20 @@
 import tomllib
 from collections.abc import Sequence
 from pathlib import Path
-from typing import Any, ClassVar, Literal, cast, get_args, overload
+from typing import Annotated, Any, ClassVar, Literal, Self, cast, get_args, overload
 
 from lgtm_ai.ai.schemas import AdditionalContext, CommentCategory, SupportedAIModels
-from lgtm_ai.base.schemas import IntOrNoLimit, OutputFormat
-from lgtm_ai.config.constants import DEFAULT_AI_MODEL, DEFAULT_INPUT_TOKEN_LIMIT
+from lgtm_ai.base.schemas import IntOrNoLimit, IssuesSource, OutputFormat
+from lgtm_ai.config.constants import DEFAULT_AI_MODEL, DEFAULT_INPUT_TOKEN_LIMIT, DEFAULT_ISSUE_REGEX
 from lgtm_ai.config.exceptions import (
     ConfigFileNotFoundError,
     InvalidConfigError,
     InvalidConfigFileError,
+    InvalidOptionsError,
     MissingRequiredConfigError,
 )
-from pydantic import BaseModel, Field, ValidationError
+from lgtm_ai.config.validators import validate_regex
+from pydantic import AfterValidator, BaseModel, Field, HttpUrl, ValidationError, model_validator
 
 logger = logging.getLogger("lgtm")
 
@@ -37,6 +39,9 @@ class PartialConfig(BaseModel):
     silent: bool = False
     ai_retries: int | None = None
     ai_input_tokens_limit: IntOrNoLimit | None = None
+    issues_url: str | None = None
+    issues_regex: str | None = None
+    issues_source: IssuesSource | None = None
 
     # Secrets
     git_api_key: str | None = None
@@ -82,13 +87,32 @@ class ResolvedConfig(BaseModel):
     ai_input_tokens_limit: int | None = DEFAULT_INPUT_TOKEN_LIMIT
     """Maximum number of input tokens allowed to send to all AI models in total."""
 
+    issues_url: HttpUrl | None = None
+    """The URL of the issues page to retrieve additional context from."""
+
+    issues_regex: Annotated[str, AfterValidator(validate_regex)] = DEFAULT_ISSUE_REGEX
+    """Regex to extract issue ID from the PR title and description."""
+
+    issues_source: IssuesSource | None = None
+    """The platform of the issues page."""
+
     # Secrets
     git_api_key: str = Field(default="", repr=False)
     """API key to interact with the git service (GitLab, GitHub, etc.)."""
 
     ai_api_key: str = Field(default="", repr=False)
     """API key to interact with the AI model service (OpenAI, etc.)."""
 
+    @model_validator(mode="after")
+    def validate_issues_options(self) -> Self:
+        all_fields = (self.issues_url, self.issues_source)
+        if any(field is not None for field in all_fields) and not all(field is not None for field in all_fields):
+            raise MissingRequiredConfigError(
+                "If any `--issues-*` configuration is provided, all issues fields must be provided. Check --help."
+            )
+        # TODO: if source is JIRA, we need to ensure we have credentials
+        return self
+
 
 class ConfigHandler:
     """Handler for the configuration of lgtm.
@@ -143,6 +167,9 @@ def _parse_config_file(self) -> PartialConfig:
                 silent=config_data.get("silent", False),
                 ai_retries=config_data.get("ai_retries", None),
                 ai_input_tokens_limit=config_data.get("ai_input_tokens_limit", None),
+                issues_url=config_data.get("issues_url", None),
+                issues_source=config_data.get("issues_source", None),
+                issues_regex=config_data.get("issues_regex", None),
             )
         except ValidationError as err:
             raise InvalidConfigError(source=file_to_read.name, errors=err.errors()) from None
@@ -203,6 +230,9 @@ def _parse_cli_args(self) -> PartialConfig:
             publish=self.cli_args.publish,
             ai_retries=self.cli_args.ai_retries or None,
             ai_input_tokens_limit=self.cli_args.ai_input_tokens_limit or None,
+            issues_url=self.cli_args.issues_url or None,
+            issues_source=self.cli_args.issues_source or None,
+            issues_regex=self.cli_args.issues_regex or None,
         )
 
     def _parse_env(self) -> PartialConfig:
@@ -219,36 +249,42 @@ def _resolve_from_multiple_sources(
         self, *, from_cli: PartialConfig, from_file: PartialConfig, from_env: PartialConfig
     ) -> ResolvedConfig:
         """Resolve the config fields given all the config sources."""
-        resolved = ResolvedConfig(
-            technologies=self.resolver.resolve_tuple_field("technologies", from_cli=from_cli, from_file=from_file),
-            categories=cast(
-                tuple[CommentCategory, ...],
-                self.resolver.resolve_tuple_field(
-                    "categories", from_cli=from_cli, from_file=from_file, default=get_args(CommentCategory)
+        try:
+            resolved = ResolvedConfig(
+                technologies=self.resolver.resolve_tuple_field("technologies", from_cli=from_cli, from_file=from_file),
+                categories=cast(
+                    tuple[CommentCategory, ...],
+                    self.resolver.resolve_tuple_field(
+                        "categories", from_cli=from_cli, from_file=from_file, default=get_args(CommentCategory)
+                    ),
                 ),
-            ),
-            exclude=self.resolver.resolve_tuple_field("exclude", from_cli=from_cli, from_file=from_file),
-            model=self.resolver.resolve_string_field(
-                "model",
-                from_cli=from_cli,
-                from_file=from_file,
-                required=False,
-                default=DEFAULT_AI_MODEL,
-            ),
-            model_url=from_cli.model_url or from_file.model_url,
-            additional_context=from_file.additional_context or (),
-            publish=from_cli.publish or from_file.publish,
-            output_format=from_cli.output_format or from_file.output_format or OutputFormat.pretty,
-            silent=from_cli.silent or from_file.silent,
-            ai_retries=from_cli.ai_retries or from_file.ai_retries,
-            git_api_key=self.resolver.resolve_string_field("git_api_key", from_cli=from_cli, from_env=from_env),
-            ai_api_key=self.resolver.resolve_string_field(
-                "ai_api_key", from_cli=from_cli, from_env=from_env, required=False, default=""
-            ),
-            ai_input_tokens_limit=_transform_nolimit_to_none(
-                from_cli.ai_input_tokens_limit or from_file.ai_input_tokens_limit or DEFAULT_INPUT_TOKEN_LIMIT
-            ),
-        )
+                exclude=self.resolver.resolve_tuple_field("exclude", from_cli=from_cli, from_file=from_file),
+                model=self.resolver.resolve_string_field(
+                    "model",
+                    from_cli=from_cli,
+                    from_file=from_file,
+                    required=False,
+                    default=DEFAULT_AI_MODEL,
+                ),
+                model_url=from_cli.model_url or from_file.model_url,
+                additional_context=from_file.additional_context or (),
+                publish=from_cli.publish or from_file.publish,
+                output_format=from_cli.output_format or from_file.output_format or OutputFormat.pretty,
+                silent=from_cli.silent or from_file.silent,
+                ai_retries=from_cli.ai_retries or from_file.ai_retries,
+                git_api_key=self.resolver.resolve_string_field("git_api_key", from_cli=from_cli, from_env=from_env),
+                ai_api_key=self.resolver.resolve_string_field(
+                    "ai_api_key", from_cli=from_cli, from_env=from_env, required=False, default=""
+                ),
+                ai_input_tokens_limit=_transform_nolimit_to_none(
+                    from_cli.ai_input_tokens_limit or from_file.ai_input_tokens_limit or DEFAULT_INPUT_TOKEN_LIMIT
+                ),
+                issues_regex=from_cli.issues_regex or from_file.issues_regex or DEFAULT_ISSUE_REGEX,
+                issues_url=from_cli.issues_url or from_file.issues_url,
+                issues_source=from_cli.issues_source or from_file.issues_source,
+            )
+        except ValidationError as err:
+            raise InvalidOptionsError(err) from None
         logger.debug("Resolved config: %s", resolved)
         return resolved
 

src/lgtm_ai/config/validators.py

@@ -0,0 +1,13 @@
+import re
+
+
+def validate_regex(value: str | None) -> str | None:
+    if value is None:
+        return value
+
+    try:
+        re.compile(value)
+    except re.error as err:
+        raise ValueError(f"Invalid regex: {err}") from err
+    else:
+        return value

src/lgtm_ai/git_client/base.py

@@ -2,7 +2,8 @@
 
 from lgtm_ai.ai.schemas import Review, ReviewGuide
 from lgtm_ai.base.schemas import PRUrl
-from lgtm_ai.git_client.schemas import ContextBranch, PRDiff, PRMetadata
+from lgtm_ai.git_client.schemas import ContextBranch, IssueContent, PRDiff, PRMetadata
+from pydantic import HttpUrl
 
 
 class GitClient(Protocol):
@@ -17,6 +18,9 @@ def publish_review(self, pr_url: PRUrl, review: Review) -> None:
     def get_pr_metadata(self, pr_url: PRUrl) -> PRMetadata:
         """Get metadata for the PR given its URL."""
 
+    def get_issue_content(self, issues_url: HttpUrl, issue_id: str) -> IssueContent | None:
+        """Fetch the content of an issue from its URL."""
+
     def publish_guide(self, pr_url: PRUrl, guide: ReviewGuide) -> None:
         """Publish a review guide to the PR."""
 

src/lgtm_ai/git_client/github.py

@@ -22,6 +22,7 @@
 from lgtm_ai.git_client.schemas import ContextBranch, PRDiff, PRMetadata
 from lgtm_ai.git_parser.exceptions import GitDiffParseError
 from lgtm_ai.git_parser.parser import DiffFileMetadata, DiffResult, parse_diff_patch
+from pydantic import HttpUrl
 
 logger = logging.getLogger("lgtm.git")
 
@@ -104,6 +105,9 @@ def get_pr_metadata(self, pr_url: PRUrl) -> PRMetadata:
 
         return PRMetadata(title=pr.title or "", description=pr.body or "")
 
+    def get_issue_content(self, issue_url: HttpUrl, issue_id: str) -> None:
+        raise NotImplementedError("GitHub issues are not yet supported")
+
     def publish_guide(self, pr_url: PRUrl, guide: ReviewGuide) -> None:
         pr = _get_pr(self.client, pr_url)
         try: