feat: add repository analysis with automated PR creation

src/agents/repository_analysis_agent/nodes.py

@@ -34,7 +34,7 @@ async def analyze_repository_structure(state: RepositoryAnalysisState) -> None:
     repo_data = await github_client.get_repository(repo, installation_id=installation_id)
     workflows = await github_client.list_directory_any_auth(
         repo_full_name=repo, path=".github/workflows", installation_id=installation_id
-    )
+        )
     contributors = await github_client.get_repository_contributors(repo, installation_id) if installation_id else []
 
     state.repository_features = RepositoryFeatures(
@@ -77,7 +77,7 @@ async def analyze_contributing_guidelines(state: RepositoryAnalysisState) -> Non
     repo = state.repository_full_name
     installation_id = state.installation_id
 
-    content = await github_client.get_file_content(
+        content = await github_client.get_file_content(
         repo, "CONTRIBUTING.md", installation_id
     ) or await github_client.get_file_content(repo, ".github/CONTRIBUTING.md", installation_id)
 
@@ -144,9 +144,40 @@ def _get_language_specific_patterns(language: str | None) -> tuple[list[str], li
     )
 
 
+def _analyze_pr_bad_habits(state: RepositoryAnalysisState) -> dict[str, Any]:
+    """
+    Analyze PR history to detect bad habits and patterns.
+
+    Returns a dict with detected issues like:
+    - missing_tests: PRs without test files
+    - short_descriptions: PRs with very short descriptions
+    - no_reviews: PRs merged without reviews
+    """
+    if not state.pr_samples:
+        return {}
+
+    issues: dict[str, Any] = {
+        "missing_tests": 0,
+        "short_descriptions": 0,
+        "no_reviews": 0,
+        "total_analyzed": len(state.pr_samples),
+    }
+
+    # Note: We can't analyze PR diffs/descriptions from the basic PR list API
+    # This would require fetching individual PR details which is expensive.
+    # For now, we return basic stats that can inform recommendations.
+
+    return issues
+
+
 def _default_recommendations(state: RepositoryAnalysisState) -> list[RuleRecommendation]:
     """
-    Return a minimal, deterministic set of diff-aware rules.
+    Return a minimal, deterministic set of diff-aware rules based on repository analysis.
+
+    Rules are generated based on:
+    1. Repository language (for test patterns)
+    2. PR history analysis (for bad habits)
+    3. Contributing guidelines (if present)
 
     Note: These recommendations use repository-specific patterns when available.
     For more advanced use cases like restricting specific authors from specific paths
@@ -161,52 +192,69 @@ def _default_recommendations(state: RepositoryAnalysisState) -> list[RuleRecomme
     # Get language-specific patterns based on repository analysis
     source_patterns, test_patterns = _get_language_specific_patterns(state.repository_features.language)
 
+    # Analyze PR history for bad habits
+    pr_issues = _analyze_pr_bad_habits(state)
+
     # Require tests when source code changes.
+    # This is especially important if we detect missing tests in PR history
+    test_reasoning = f"Default guardrail for code changes without tests. Patterns adapted for {state.repository_features.language or 'multi-language'} repository."
+    if pr_issues.get("missing_tests", 0) > 0:
+        test_reasoning += f" Detected {pr_issues['missing_tests']} recent PRs without test files."
+
     recommendations.append(
         RuleRecommendation(
             yaml_rule=textwrap.dedent(
                 f"""
                 description: "Require tests when code changes"
-                enabled: true
+enabled: true
                 severity: medium
-                event_types:
-                  - pull_request
-                parameters:
+event_types:
+  - pull_request
+    parameters:
                   source_patterns:
 {chr(10).join(f'                    - "{pattern}"' for pattern in source_patterns)}
                   test_patterns:
 {chr(10).join(f'                    - "{pattern}"' for pattern in test_patterns)}
                 """
             ).strip(),
-            confidence=0.74,
-            reasoning=f"Default guardrail for code changes without tests. Patterns adapted for {state.repository_features.language or 'multi-language'} repository.",
+            confidence=0.74 if pr_issues.get("missing_tests", 0) == 0 else 0.85,
+            reasoning=test_reasoning,
             strategy_used="hybrid",
         )
     )
 
     # Require description in PR body.
+    # Increase confidence if we detect short descriptions in PR history
+    desc_reasoning = "Encourage context for reviewers; lightweight default."
+    if pr_issues.get("short_descriptions", 0) > 0:
+        desc_reasoning += f" Detected {pr_issues['short_descriptions']} PRs with insufficient descriptions."
+
     recommendations.append(
         RuleRecommendation(
             yaml_rule=textwrap.dedent(
                 """
                 description: "Ensure PRs include context"
-                enabled: true
+enabled: true
                 severity: low
-                event_types:
-                  - pull_request
-                parameters:
+event_types:
+  - pull_request
+    parameters:
                   min_description_length: 50
                 """
             ).strip(),
-            confidence=0.68,
-            reasoning="Encourage context for reviewers; lightweight default.",
+            confidence=0.68 if pr_issues.get("short_descriptions", 0) == 0 else 0.80,
+            reasoning=desc_reasoning,
             strategy_used="static",
         )
     )
 
-    # If no CODEOWNERS, suggest one for shared ownership signals.
-    # Note: This is informational only - we can't enforce CODEOWNERS creation via validators
-    # but we can encourage it through the recommendation reasoning.
+    # If contributing guidelines require tests, increase confidence
+    if state.contributing_analysis.has_contributing and state.contributing_analysis.requires_tests:
+        # Find the test rule and boost its confidence
+        for rec in recommendations:
+            if "tests" in rec.yaml_rule.lower():
+                rec.confidence = min(0.95, rec.confidence + 0.1)
+                rec.reasoning += " Contributing guidelines explicitly require tests."
 
     return recommendations
 
@@ -234,7 +282,7 @@ def _default_pr_plan(state: RepositoryAnalysisState) -> PullRequestPlan:
 
 def validate_recommendations(state: RepositoryAnalysisState) -> None:
     """Ensure generated YAML is valid."""
-    for rec in state.recommendations:
+        for rec in state.recommendations:
         yaml.safe_load(rec.yaml_rule)
 
 

src/api/recommendations.py

@@ -171,11 +171,16 @@ async def proceed_with_pr(request: ProceedWithPullRequestRequest) -> ProceedWith
                 operation="proceed_with_pr",
                 subject_ids=[repo],
                 branch=request.branch_name,
+                base_branch=base_branch,
                 base_sha=base_sha,
-                error="Failed to create branch",
+                error="Failed to create branch - check logs for GitHub API error details",
             )
             raise HTTPException(
-                status_code=400, detail=f"Failed to create branch '{request.branch_name}'. It may already exist."
+                status_code=400,
+                detail=(
+                    f"Failed to create branch '{request.branch_name}' from '{base_branch}'. "
+                    "The branch may already exist or you may not have permission to create branches."
+                ),
             )
 
     file_result = await github_client.create_or_update_file(
@@ -194,9 +199,15 @@ async def proceed_with_pr(request: ProceedWithPullRequestRequest) -> ProceedWith
             subject_ids=[repo],
             branch=request.branch_name,
             file_path=request.file_path,
-            error="Failed to create or update file",
+            error="Failed to create or update file - check logs for GitHub API error details",
+        )
+        raise HTTPException(
+            status_code=400,
+            detail=(
+                f"Failed to create or update file '{request.file_path}' on branch '{request.branch_name}'. "
+                "Check server logs for detailed error information."
+            ),
         )
-        raise HTTPException(status_code=400, detail="Failed to create or update rules file")
 
     pr = await github_client.create_pull_request(
         repo_full_name=repo,
@@ -214,9 +225,16 @@ async def proceed_with_pr(request: ProceedWithPullRequestRequest) -> ProceedWith
             subject_ids=[repo],
             branch=request.branch_name,
             base_branch=base_branch,
-            error="Failed to create pull request",
+            pr_title=request.pr_title,
+            error="Failed to create pull request - check logs for GitHub API error details",
+        )
+        raise HTTPException(
+            status_code=400,
+            detail=(
+                f"Failed to create pull request from '{request.branch_name}' to '{base_branch}'. "
+                "The PR may already exist, or you may not have permission to create PRs. Check server logs for details."
+            ),
         )
-        raise HTTPException(status_code=400, detail="Failed to create pull request")
 
     pr_url = pr.get("html_url", "")
     if not pr_url:

src/integrations/github/api.py

@@ -813,6 +813,7 @@ async def create_or_update_file(
         """Create or update a file via the Contents API."""
         headers = await self._get_auth_headers(installation_id=installation_id, user_token=user_token)
         if not headers:
+            logger.error(f"Failed to get auth headers for create_or_update_file in {repo_full_name}")
             return None
         url = f"{config.github.api_base_url}/repos/{repo_full_name}/contents/{path.lstrip('/')}"
         payload: dict[str, Any] = {
@@ -825,7 +826,14 @@ async def create_or_update_file(
         session = await self._get_session()
         async with session.put(url, headers=headers, json=payload) as response:
             if response.status in (200, 201):
-                return await response.json()
+                result = await response.json()
+                logger.info(f"Successfully created/updated file {path} in {repo_full_name} on branch {branch}")
+                return result
+            error_text = await response.text()
+            logger.error(
+                f"Failed to create/update file {path} in {repo_full_name} on branch {branch}. "
+                f"Status: {response.status}, Response: {error_text}"
+            )
             return None
 
     async def create_pull_request(
@@ -841,13 +849,26 @@ async def create_pull_request(
         """Open a pull request."""
         headers = await self._get_auth_headers(installation_id=installation_id, user_token=user_token)
         if not headers:
+            logger.error(f"Failed to get auth headers for create_pull_request in {repo_full_name}")
             return None
         url = f"{config.github.api_base_url}/repos/{repo_full_name}/pulls"
         payload = {"title": title, "head": head, "base": base, "body": body}
         session = await self._get_session()
         async with session.post(url, headers=headers, json=payload) as response:
             if response.status in (200, 201):
-                return await response.json()
+                result = await response.json()
+                pr_number = result.get("number")
+                pr_url = result.get("html_url", "")
+                logger.info(
+                    f"Successfully created PR #{pr_number} in {repo_full_name}: {pr_url} "
+                    f"(head: {head}, base: {base})"
+                )
+                return result
+            error_text = await response.text()
+            logger.error(
+                f"Failed to create PR in {repo_full_name} (head: {head}, base: {base}). "
+                f"Status: {response.status}, Response: {error_text}"
+            )
             return None
 
     async def _get_session(self) -> aiohttp.ClientSession: