Merge branch 'main' into issue-93-handle-failing-pipelines

aider_gitea/__init__.py

@@ -103,7 +103,11 @@ class RepositoryConfig:
 class IssueResolution:
     success: bool
     pull_request_url: str | None = None
-    pull_request_id: str | None = None
+    pull_request_id: int | None = None
+
+    def __post_init__(self):
+        assert self.pull_request_id is None or isinstance(self.pull_request_id, int)
+        assert self.pull_request_url is None or isinstance(self.pull_request_url, str)
 
 
 def generate_branch_name(issue_number: str, issue_title: str) -> str:
@@ -283,8 +287,8 @@ def push_changes(
     # Extract PR number and URL if available
     return IssueResolution(
         True,
-        str(pr_response.get('number')),
         pr_response.get('html_url'),
+        int(pr_response.get('number')),
     )
 
 
@@ -383,6 +387,9 @@ def run_ollama_and_get_yes_or_no(cwd, initial_texts: list[str]) -> bool:
 
 
 def verify_solution(repository_path: Path, issue_content: str) -> bool:
+    if not EVALUATOR_MODEL:
+        return True
+
     summary = run_ollama(
         repository_path,
         [
@@ -502,21 +509,21 @@ def solve_issues_in_repository(
         title = issue.get('title', f'Issue {issue_number}')
         if seen_issues_db.has_seen(issue_url):
             logger.info('Skipping already processed issue #%s: %s', issue_number, title)
-            continue
+        else:
+            branch_name = generate_branch_name(issue_number, title)
+            with tempfile.TemporaryDirectory() as repository_path:
+                issue_resolution = solve_issue_in_repository(
+                    repository_config,
+                    Path(repository_path),
+                    branch_name,
+                    title,
+                    issue_description,
+                    issue_number,
+                    client,
+                )
 
-        branch_name = generate_branch_name(issue_number, title)
-        with tempfile.TemporaryDirectory() as repository_path:
-            issue_resolution = solve_issue_in_repository(
-                repository_config,
-                Path(repository_path),
-                branch_name,
-                title,
-                issue_description,
-                issue_number,
-                client,
-            )
-
-        if issue_resolution.success:
+        # TODO: PR comment handling disabled for now due to missing functionality
+        if False:
             # Handle unresolved pull request comments
             handle_pr_comments(
                 repository_config,
@@ -527,6 +534,15 @@ def solve_issues_in_repository(
                 seen_issues_db,
                 issue_url,
             )
+
+            # Handle failing pipelines
+            handle_failing_pipelines(
+                repository_config,
+                issue_resolution.pull_request_id,
+                branch_name,
+                Path(repository_path),
+                client,
+            )
             seen_issues_db.mark_as_seen(issue_url, str(issue_number))
             seen_issues_db.update_pr_info(
                 issue_url,
@@ -542,7 +558,7 @@ def solve_issues_in_repository(
 
 def handle_pr_comments(
     repository_config,
-    pr_number,
+    pr_number: int,
     branch_name,
     repository_path,
     client,
@@ -581,3 +597,40 @@ def handle_pr_comments(
             check=False,
         )
         run_cmd(['git', 'push', 'origin', branch_name], repository_path, check=False)
+
+
+def handle_failing_pipelines(
+    repository_config: RepositoryConfig,
+    pr_number: str,
+    branch_name: str,
+    repository_path: Path,
+    client,
+) -> None:
+    """Fetch failing pipelines for the given PR and resolve them via aider."""
+    while True:
+        failed_runs = client.get_failed_pipelines(
+            repository_config.owner,
+            repository_config.repo,
+            pr_number,
+        )
+        if not failed_runs:
+            break
+        for run_id in failed_runs:
+            log = client.get_pipeline_log(
+                repository_config.owner,
+                repository_config.repo,
+                run_id,
+            )
+            lines = log.strip().split('\n')
+            context = '\n'.join(lines[-100:])
+            issue = f'Resolve the following failing pipeline run {run_id}:\n\n{context}'
+            issue_solution_round(repository_path, issue)
+            run_cmd(['git', 'add', '.'], repository_path, check=False)
+            run_cmd(
+                ['git', 'commit', '-m', f'Resolve pipeline {run_id}'],
+                repository_path,
+                check=False,
+            )
+            run_cmd(
+                ['git', 'push', 'origin', branch_name], repository_path, check=False,
+            )

aider_gitea/__main__.py

@@ -45,6 +45,16 @@ def parse_args():
         default=300,
         help='Interval in seconds between checks in daemon mode (default: 300)',
     )
+    parser.add_argument(
+        '--aider-model',
+        help='Model to use for generating code (overrides default)',
+        default=None,
+    )
+    parser.add_argument(
+        '--evaluator-model',
+        help='Model to use for evaluating code (overrides default)',
+        default=None,
+    )
     return parser.parse_args()
 
 
@@ -52,6 +62,14 @@ def main():
     logging.basicConfig(level='INFO')
     args = parse_args()
 
+    # Override default models if provided
+    import aider_gitea as core
+
+    if args.aider_model:
+        core.CODE_MODEL = args.aider_model
+    if args.evaluator_model:
+        core.EVALUATOR_MODEL = args.evaluator_model
+
     seen_issues_db = SeenIssuesDB()
     client = GiteaClient(args.gitea_url, secrets.gitea_token())
 

aider_gitea/gitea_client.py

@@ -166,19 +166,56 @@ class GiteaClient:
         }
 
         response = self.session.post(url, json=json_data)
+        # If a pull request for this head/base already exists, return it instead of crashing
+        if response.status_code == 409:
+            logger.warning(
+                'Pull request already exists for head %s and base %s',
+                head,
+                base,
+            )
+            prs = self.get_pull_requests(owner, repo)
+            for pr in prs:
+                if (
+                    pr.get('head', {}).get('ref') == head
+                    and pr.get('base', {}).get('ref') == base
+                ):
+                    return pr
+            # fallback to raise if we can’t find it
+            response.raise_for_status()
         response.raise_for_status()
         return response.json()
 
-    def get_pull_request_comments(
+    def get_failed_pipelines(self, owner: str, repo: str, pr_number: str) -> list[int]:
+        """Fetch pipeline runs for a PR and return IDs of failed runs."""
+        url = f'{self.gitea_url}/repos/{owner}/{repo}/actions/runs'
+        response = self.session.get(url)
+        response.raise_for_status()
+        runs = response.json().get('workflow_runs', [])
+        failed = []
+        for run in runs:
+            if any(
+                pr.get('number') == int(pr_number)
+                for pr in run.get('pull_requests', [])
+            ):
+                if run.get('conclusion') not in ('success',):
+                    failed.append(run.get('id'))
+        return failed
+
+    def get_pipeline_log(self, owner: str, repo: str, run_id: int) -> str:
+        """Download the logs for a pipeline run."""
+        url = f'{self.gitea_url}/repos/{owner}/{repo}/actions/runs/{run_id}/logs'
+        response = self.session.get(url)
+        response.raise_for_status()
+        return response.text
+
+    def get_pull_requests(
         self,
         owner: str,
         repo: str,
-        pr_number: str,
+        state: str = 'open',
     ) -> list[dict]:
-        """
-        Fetch comments for a pull request.
-        """
-        url = f'{self.gitea_url}/repos/{owner}/{repo}/pulls/{pr_number}/comments'
+        """Fetch pull requests for a repository."""
+        url = f'{self.gitea_url}/repos/{owner}/{repo}/pulls?state={state}'
         response = self.session.get(url)
         response.raise_for_status()
         return response.json()