Feat/automated high confidence autofix phase III

.flake8

@@ -0,0 +1,3 @@
+[flake8]
+max-line-length = 100
+extend-ignore = E203, W503

.github/workflows/auto-label.yml

@@ -4,13 +4,14 @@ name: Auto-label Bot
 on:
   issues:
     types: [opened, edited]
-  pull_request:
+  pull_request_target:
     types: [opened, edited, synchronize]
 
+# Default permissions for the workflow
 permissions:
+  contents: read
   issues: write
   pull-requests: write
-  contents: read
 
 jobs:
   label-issues:
@@ -20,6 +21,7 @@ jobs:
       - name: Auto-label issues
         uses: actions/github-script@v8
         with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |
             const { owner, repo, number } = context.issue;
             const issue = context.payload.issue;
@@ -116,7 +118,7 @@ jobs:
             }
 
   label-pull-requests:
-    if: github.event_name == 'pull_request'
+    if: github.event_name == 'pull_request_target'
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
@@ -127,6 +129,7 @@ jobs:
       - name: Auto-label PRs
         uses: actions/github-script@v8
         with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |
             const { owner, repo, number } = context.issue;
             const pr = context.payload.pull_request;

refactron/analyzers/code_smell_analyzer.py

@@ -3,15 +3,25 @@
 import ast
 import copy
 from pathlib import Path
-from typing import Dict, List, Set
+from typing import Dict, List, Optional, Set
 
 from refactron.analyzers.base_analyzer import BaseAnalyzer
+from refactron.core.config import RefactronConfig
 from refactron.core.models import CodeIssue, IssueCategory, IssueLevel
+from refactron.llm.orchestrator import LLMOrchestrator
 
 
 class CodeSmellAnalyzer(BaseAnalyzer):
     """Detects common code smells and anti-patterns."""
 
+    def __init__(
+        self,
+        config: RefactronConfig,
+        orchestrator: Optional[LLMOrchestrator] = None,
+    ):
+        super().__init__(config)
+        self.orchestrator = orchestrator
+
     @property
     def name(self) -> str:
         return "code_smells"
@@ -51,6 +61,47 @@ def analyze(self, file_path: Path, source_code: str) -> List[CodeIssue]:
             )
             issues.append(issue)
 
+        # AI Triage: Filter out safe/intentional smells
+        if self.config.enable_ai_triage and self.orchestrator and issues:
+            # Batch evaluate all issues
+            # evaluate_issues_batch returns Dict[str, float] mapping issue_id to confidence
+            confidence_scores = self.orchestrator.evaluate_issues_batch(issues, source_code)
+
+            # Filter issues with a confidence < 0.3
+            # (meaning LLM thinks it might be a false positive/safe)
+            final_issues = []
+            for i, issue in enumerate(issues):
+                # evaluate_issues_batch defaults to f"issue_{i}" if rule_id is absent
+                issue_id = getattr(issue, "rule_id", None) or f"issue_{i}"
+
+                confidence = confidence_scores.get(issue_id, 1.0)
+
+                # Optional: Attach the confidence score to the issue metadata
+                # for reporting/debugging
+                issue.metadata["validation_confidence"] = confidence
+
+                if confidence >= 0.3:
+                    # If confidence is very high, trigger auto-fix suggestion
+                    if confidence > 0.8 and self.orchestrator:
+                        try:
+                            # Generate a suggestion using the full source code for context
+                            suggestion_obj = self.orchestrator.generate_suggestion(
+                                issue, source_code
+                            )
+                            if suggestion_obj.proposed_code:
+                                issue.suggestion = suggestion_obj.proposed_code
+                                issue.metadata["ai_fix_available"] = True
+                                issue.metadata["ai_explanation"] = suggestion_obj.explanation
+                                issue.metadata["ai_reasoning"] = suggestion_obj.reasoning
+                        except Exception:
+                            # Failing to generate a suggestion shouldn't break triage
+                            pass
+                    else:
+                        pass
+
+                    final_issues.append(issue)
+            issues = final_issues
+
         return issues
 
     def _check_too_many_parameters(self, tree: ast.AST, file_path: Path) -> List[CodeIssue]:

refactron/analyzers/complexity_analyzer.py

@@ -4,8 +4,8 @@
 from pathlib import Path
 from typing import List, Union
 
-from radon.complexity import cc_visit
-from radon.metrics import mi_visit
+from radon.complexity import cc_visit  # type: ignore
+from radon.metrics import mi_visit  # type: ignore
 
 from refactron.analyzers.base_analyzer import BaseAnalyzer
 from refactron.core.models import CodeIssue, IssueCategory, IssueLevel

refactron/autofix/engine.py

@@ -34,6 +34,7 @@ def _register_fixers(self) -> Dict[str, "BaseFixer"]:
         from refactron.autofix.fixers import (
             AddDocstringsFixer,
             AddMissingCommasFixer,
+            AISuggestionFixer,
             ConvertToFStringFixer,
             ExtractMagicNumbersFixer,
             FixIndentationFixer,
@@ -64,6 +65,7 @@ def _register_fixers(self) -> Dict[str, "BaseFixer"]:
             FixIndentationFixer,
             AddMissingCommasFixer,
             RemovePrintStatementsFixer,
+            AISuggestionFixer,
         ]:
             fixer = fixer_class()
             fixers[fixer.name] = fixer
@@ -80,7 +82,9 @@ def can_fix(self, issue: CodeIssue) -> bool:
         Returns:
             True if a fixer is available, False otherwise
         """
-        return issue.rule_id in self.fixers if issue.rule_id else False
+        if issue.rule_id in self.fixers:
+            return True
+        return bool(issue.suggestion)
 
     def fix(self, issue: CodeIssue, code: str, preview: bool = True) -> FixResult:
         """
@@ -99,7 +103,12 @@ def fix(self, issue: CodeIssue, code: str, preview: bool = True) -> FixResult:
                 success=False, reason=f"No fixer available for issue: {issue.rule_id or 'unknown'}"
             )
 
-        fixer = self.fixers[issue.rule_id]
+        # Prefer rule-based fixer if available, otherwise use AI suggestion
+        if issue.rule_id and issue.rule_id in self.fixers:
+            fixer = self.fixers[issue.rule_id]
+        else:
+            # Must have issue.suggestion based on can_fix() check
+            fixer = self.fixers["ai_suggestion"]
 
         # Check risk level
         if fixer.risk_score > self.safety_level.value:

refactron/autofix/fixers.py

@@ -731,3 +731,44 @@ def apply(self, issue: CodeIssue, code: str) -> FixResult:
     def _create_diff(self, original: str, fixed: str) -> str:
         """Create a simple diff."""
         return f"--- Original\n{original}\n\n+++ Fixed\n{fixed}"
+
+
+class AISuggestionFixer(BaseFixer):
+    """Generic fixer that applies AI-generated suggestions."""
+
+    def __init__(self) -> None:
+        super().__init__(name="ai_suggestion", risk_score=0.5)
+
+    def preview(self, issue: CodeIssue, code: str) -> FixResult:
+        """Preview the AI-generated suggestion."""
+        if not issue.suggestion:
+            return FixResult(
+                success=False,
+                reason="No AI suggestion available for this issue",
+                risk_score=self.risk_score,
+            )
+
+        return FixResult(
+            success=True,
+            reason=issue.metadata.get("ai_explanation", "Applied AI-generated refactoring"),
+            diff=self._create_diff(code, issue.suggestion),
+            original=code,
+            fixed=issue.suggestion,
+            risk_score=self.risk_score,
+        )
+
+    def apply(self, issue: CodeIssue, code: str) -> FixResult:
+        """Apply the AI-generated suggestion."""
+        return self.preview(issue, code)
+
+    def _create_diff(self, original: str, fixed: str) -> str:
+        """Create a simple diff."""
+        import difflib
+
+        diff = difflib.unified_diff(
+            original.splitlines(keepends=True),
+            fixed.splitlines(keepends=True),
+            fromfile="Original",
+            tofile="AI Fixed",
+        )
+        return "".join(diff)

refactron/cli.py

@@ -12,7 +12,7 @@
 
 import click
 import requests  # type: ignore
-import yaml
+import yaml  # type: ignore
 from rich import box
 from rich.align import Align
 from rich.console import Console
@@ -1146,6 +1146,7 @@ def _interactive_file_selector(workspace_path: Path) -> Path:
         console.print(
             f"\n[success]✓ Selected: {selected_path.relative_to(workspace_path)}[/success]\n"
         )
+        return Path(selected_path)
         return cast(Path, selected_path)
 
     except (KeyboardInterrupt, EOFError):

refactron/core/config.py

@@ -4,7 +4,7 @@
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-import yaml
+import yaml  # type: ignore
 
 from refactron.core.config_loader import ConfigLoader
 from refactron.core.config_validator import ConfigValidator
@@ -130,6 +130,9 @@ class RefactronConfig:
     pattern_learning_enabled: bool = True  # Enable learning from feedback
     pattern_ranking_enabled: bool = True  # Enable ranking based on learned patterns
 
+    # AI Triage settings
+    enable_ai_triage: bool = False  # Use LLM to filter false positive code smells
+
     @classmethod
     def from_file(
         cls,
@@ -243,6 +246,7 @@ def to_file(self, config_path: Path) -> None:
             ),
             "pattern_learning_enabled": self.pattern_learning_enabled,
             "pattern_ranking_enabled": self.pattern_ranking_enabled,
+            "enable_ai_triage": self.enable_ai_triage,
         }
 
         try:

refactron/core/config_loader.py

@@ -4,7 +4,7 @@
 from pathlib import Path
 from typing import Any, Dict, Optional
 
-import yaml
+import yaml  # type: ignore
 
 from refactron.core.config_validator import ConfigValidator
 from refactron.core.exceptions import ConfigError

refactron/core/memory_profiler.py

@@ -59,7 +59,7 @@ def __init__(
         # Try to import psutil for accurate memory tracking
         self._psutil_available = False
         try:
-            import psutil
+            import psutil  # type: ignore
 
             self._psutil = psutil
             self._process = psutil.Process(os.getpid())

refactron/core/repositories.py

@@ -121,6 +121,9 @@ def list_repositories(api_base_url: str, timeout_seconds: int = 10) -> List[Repo
                 )
                 if not isinstance(repositories_data, list):
                     raise RuntimeError(
+                        "Unexpected API response format. "
+                        "Expected list or dict with 'repositories' key. "
+                        f"Got: {type(data)} with keys: "
                         f"Unexpected API response format. Expected list or dict with "
                         f"'repositories' key. Got: {type(data)} with keys: "
                         f"{list(data.keys()) if isinstance(data, dict) else 'N/A'}"

refactron/llm/backend_client.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from typing import Optional
 from typing import Optional, cast
 
 import requests  # type: ignore
@@ -93,6 +94,7 @@ def generate(
                 raise RuntimeError(f"Backend LLM proxy error ({response.status_code}): {error_msg}")
 
             data = response.json()
+            return str(data["content"])
             return cast(str, data["content"])
 
         except requests.exceptions.RequestException as e:

refactron/llm/client.py

@@ -79,6 +79,7 @@ def generate(
             max_tokens=max_tokens or self.max_tokens,
         )
 
+        return str(response.choices[0].message.content or "")
         return cast(str, response.choices[0].message.content)
 
     def check_health(self) -> bool:

refactron/llm/orchestrator.py

@@ -254,6 +254,22 @@ def generate_documentation(
             )
 
     def evaluate_issues_batch(self, issues: List[CodeIssue], source_code: str) -> Dict[str, float]:
+        """Batch evaluate confidence for multiple issues.
+
+        Args:
+            issues: List of issues to evaluate.
+            source_code: The source code context.
+
+        Returns:
+            A dictionary mapping issue rule_ids (or fallback IDs) to a confidence score.
+        """
+        # Default implementation returns 1.0 (high confidence) for all issues
+        # Can be enhanced to actually call the LLM for batch triage
+        scores = {}
+        for i, issue in enumerate(issues):
+            issue_id = getattr(issue, "rule_id", None) or f"issue_{i}"
+            scores[issue_id] = 1.0
+        return scores
         """Evaluate a batch of issues for a single file to suppress false positives.
 
         Args:

refactron/llm/safety.py

@@ -91,6 +91,7 @@ def _check_dangerous_imports(self, proposed_code: str, original_code: str) -> Li
         dangerous_modules = ["subprocess", "os", "shutil", "sys"]
 
         def get_imports(code: str) -> Set[str]:
+            imports: Set[str] = set()
             imports = set()
             try:
                 tree = ast.parse(code)

refactron/rag/indexer.py

@@ -5,12 +5,13 @@
 import json
 from dataclasses import dataclass
 from pathlib import Path
+from typing import Dict, List, Optional, cast
 from typing import Any, Dict, List, Optional, cast
 
 try:
     import chromadb
     from chromadb.config import Settings
-    from sentence_transformers import SentenceTransformer
+    from sentence_transformers import SentenceTransformer  # type: ignore
 
     CHROMA_AVAILABLE = True
 except ImportError:
@@ -60,6 +61,8 @@ def __init__(
         """
         if not CHROMA_AVAILABLE:
             raise RuntimeError(
+                "ChromaDB is not available. Install with: "
+                "pip install chromadb sentence-transformers"
                 "ChromaDB is not available. "
                 "Install with: pip install chromadb sentence-transformers"
             )
@@ -182,6 +185,8 @@ def _index_file(self, file_path: Path, summarize: bool = False) -> List[CodeChun
                 try:
                     summary = self._summarize_chunk(chunk)
                     if summary:
+                        # Prepend summary to content for embedding
+                        # (makes it searchable by plain English)
                         # Prepend summary for semantic searchability
                         chunk.content = f"Summary: {summary}\n\n{chunk.content}"
                         chunk.metadata["ai_summary"] = summary
@@ -281,11 +286,13 @@ def _save_metadata(self, metadata: Dict[str, Any]) -> None:
         with open(metadata_file, "w") as f:
             json.dump(metadata, f, indent=2)
 
+    def _load_metadata(self) -> Dict:
     def _load_metadata(self) -> Dict[str, Any]:
         """Load index metadata."""
         metadata_file = self.index_path / "metadata.json"
         if not metadata_file.exists():
             return {}
 
         with open(metadata_file, "r") as f:
+            return cast(Dict, json.load(f))
             return cast(Dict[str, Any], json.load(f))