@ngocsangairvds/vsaf 3.2.13 → 3.2.15

package/tools/vds-scripts/audit_orchestrator/src/vds_audit_orchestrator/agents/code_agent.py

@@ -1,667 +0,0 @@
-"""Code analysis agent implementation."""
-
-from __future__ import annotations
-
-import time
-from pathlib import Path
-from typing import Any
-
-from structlog import get_logger
-from vds_agent_core.config import LLMProtocolType
-from vds_agent_core.skills.executor import SkillExecutor
-from vds_agent_core.skills.manager import SkillManager
-
-from vds_audit_orchestrator.agents.agentic_investigator import (
-    AGENTIC_CODE_ANALYSIS_SYSTEM_PROMPT,
-    AgenticInvestigator,
-)
-from vds_audit_orchestrator.agents.base import AgentResult, BaseAgent
-from vds_audit_orchestrator.agents.code_analysis_helpers import (
-    format_code_pack_for_review,
-    get_repo_path,
-    merge_findings_with_deduplication,
-    prepare_code_samples,
-    scan_for_patterns,
-    summarize_selected_files,
-)
-from vds_audit_orchestrator.agents.code_analysis_prompts import (
-    CODE_ANALYSIS_SYSTEM_PROMPT,
-    LLM_CODE_REVIEW_SYSTEM_PROMPT,
-    build_llm_code_review_prompt,
-)
-from vds_audit_orchestrator.agents.pydantic_base import (
-    AuditDeps,
-    CodeFindings,
-    _build_toolsets,
-)
-from vds_audit_orchestrator.agents.security_scanner import (
-    SECURITY_PATTERNS,
-    SecurityPatternScanner,
-)
-from vds_audit_orchestrator.agents.tool_efficiency_guard import ToolEfficiencyGuard
-from vds_audit_orchestrator.config import get_config
-from vds_audit_orchestrator.errors import AUDIT_ERROR_CODES, AuditError
-from vds_audit_orchestrator.evidence.code_pack import CodeEvidencePack, CodePackBuilder
-from vds_audit_orchestrator.evidence.corpus import EvidenceCorpus, deserialize_evidence_corpus
-from vds_audit_orchestrator.models.evidence import EvidenceBundle
-from vds_audit_orchestrator.models.task import AuditTask
-
-logger = get_logger()
-
-__all__ = [
-    "AGENTIC_CODE_ANALYSIS_SYSTEM_PROMPT",
-    "CODE_ANALYSIS_SYSTEM_PROMPT",
-    "LLM_CODE_REVIEW_SYSTEM_PROMPT",
-    "AgenticInvestigator",
-    "CodeAnalysisAgent",
-    "LLMProtocolType",
-    "SkillManager",
-    "ToolEfficiencyGuard",
-    "_build_toolsets",
-    "get_config",
-]
-
-
-class CodeAnalysisAgent(AgenticInvestigator, BaseAgent):
-    """Agent for multi-layer code analysis (pattern scanner + LLM + agentic modes)."""
-
-    AGENT_NAME = "CodeAnalysisAgent"
-
-    # Maximum total characters of code content to embed in a single LLM prompt.
-    # ~7.5K tokens — safe for local models (8K-32K context) and avoids prompt
-    # bloat for cloud models. Agentic mode bypasses this via tool-first retrieval.
-    MAX_TOTAL_CODE_CONTEXT_CHARS: int = 30_000
-
-    def __init__(self, *args, agentic_mode: str = "auto", **kwargs):
-        """Initialize the CodeAnalysisAgent.
-
-        Args:
-            agentic_mode: Investigation mode - "auto" (default), "off" (FAST), or "on" (AGENTIC).
-        """
-        super().__init__(*args, **kwargs)
-        self._profile: dict[str, Any] = {}
-        self._evidence_corpus: EvidenceCorpus | None = None
-        self._state_context: dict[str, Any] = {}
-        self._agentic_mode = agentic_mode
-
-    @staticmethod
-    def _get_runtime_config():
-        """Return runtime config accessor used by agentic mixin logic."""
-        return get_config()
-
-    @staticmethod
-    def _build_runtime_toolsets(llm_config: Any):
-        """Build provider toolsets used by agentic mixin logic."""
-        return _build_toolsets(llm_config)
-
-    @staticmethod
-    def _runtime_protocol_type():
-        """Return protocol enum for agentic runtime routing."""
-        return LLMProtocolType
-
-    async def analyze(
-        self,
-        evidence: EvidenceBundle | dict | AuditTask,
-        profile: dict[str, Any] | None = None,
-    ) -> AgentResult:
-        """Analyze code evidence and return layered findings with metadata."""
-        findings: list[dict[str, Any]] = []
-        metadata: dict[str, Any] = {
-            "analysis_layers": [],
-            "pattern_scanner_used": False,
-            "llm_code_review_used": False,
-        }
-        SkillExecutor.reset_usage()
-
-        # Normalize evidence input for backward compatibility
-        evidence_bundle = self._normalize_evidence(evidence)
-        if evidence_bundle is None:
-            return self._result(
-                agent_name=self.AGENT_NAME,
-                success=False,
-                error=AuditError(
-                    code=AUDIT_ERROR_CODES["AGENT_EVIDENCE_MISSING"],
-                    message="Evidence bundle missing or invalid",
-                    template_params={"agent_name": self.AGENT_NAME},
-                ),
-            )
-
-        # Use profile from argument or extracted from dict evidence
-        effective_profile = profile or self._profile
-
-        # Layer 1: Scoped pattern scanning via SecurityPatternScanner (FR-1.1)
-        repo_path = self._get_repo_path(evidence_bundle, effective_profile)
-        pattern_scanner_findings: list[dict[str, Any]] = []
-        if repo_path:
-            pattern_scanner_findings = await self._scan_security_patterns(repo_path)
-            if pattern_scanner_findings:
-                metadata["analysis_layers"].append("pattern_scanner_security")
-                metadata["pattern_scanner_used"] = True
-                metadata["pattern_scanner_findings"] = len(pattern_scanner_findings)
-                metadata["repo_path"] = str(repo_path)
-        else:
-            self.logger.warning(
-                "security_pattern_scan_skipped",
-                reason="repo_path not available",
-            )
-            metadata["pattern_scanner_skipped"] = "repo_path not available"
-
-        # Phase 41 routing decision: resolve AGENTIC vs FAST before expensive LLM review.
-        agentic_runtime = self._resolve_agentic_runtime()
-        requested_agentic = self._agentic_mode == "on" or (self._agentic_mode == "auto" and repo_path is not None)
-        use_agentic = requested_agentic and agentic_runtime is not None
-        metadata["agentic_mode"] = self._agentic_mode
-        metadata["agentic_requested"] = requested_agentic
-        metadata["agentic_active"] = use_agentic
-        metadata["agentic_runtime"] = agentic_runtime or {"enabled": False}
-        self.logger.debug(
-            "phase41_routing_decision",
-            agentic_mode=self._agentic_mode,
-            requested_agentic=requested_agentic,
-            use_agentic=use_agentic,
-            repo_path=str(repo_path) if repo_path else None,
-            llm_enabled=self.settings.enabled,
-            has_evidence=bool(evidence_bundle.git_evidence),
-        )
-
-        # Layer 2: LLM-based semantic code review using CodeEvidencePack (FR-1.3)
-        # Tool-first hard cut: when AGENTIC is active, skip inline code review prompting.
-        # Budget guard: _select_files_for_llm enforces MAX_TOTAL_CODE_CONTEXT_CHARS to
-        # prevent prompt bloat in non-agentic mode.
-        llm_code_review_findings: list[dict[str, Any]] = []
-        if use_agentic:
-            metadata["llm_code_review_skipped"] = "agentic_tool_first"
-            self.logger.info(
-                "llm_code_review_skipped",
-                reason="agentic_tool_first",
-                repo_path=str(repo_path) if repo_path else None,
-            )
-        else:
-            runtime_config = self._get_runtime_config()
-            if not bool(getattr(runtime_config.llm, "code_review_layer_enabled", True)):
-                metadata["llm_code_review_skipped"] = "disabled_by_config"
-                self.logger.info(
-                    "llm_code_review_skipped",
-                    reason="disabled_by_config",
-                    repo_path=str(repo_path) if repo_path else None,
-                )
-            elif repo_path and self.settings.enabled:
-                try:
-                    code_pack = self._build_code_pack(repo_path)
-                    if code_pack and code_pack.total_files_included > 0:
-                        llm_input_files = self._select_files_for_llm(
-                            code_pack,
-                            max_files=int(runtime_config.llm.code_review_max_files),
-                            max_total_chars=int(runtime_config.llm.code_review_max_total_chars),
-                        )
-                        llm_input_source_files = sum(
-                            1 for file_ev in llm_input_files if self._is_source_code_file(file_ev.file_path)
-                        )
-                        metadata["code_pack_scanned"] = code_pack.total_files_scanned
-                        metadata["code_pack_included"] = code_pack.total_files_included
-                        metadata["code_pack_files"] = [file_ev.file_path for file_ev in code_pack.files]
-                        metadata["llm_input_files"] = [file_ev.file_path for file_ev in llm_input_files]
-                        metadata["llm_input_file_count"] = len(llm_input_files)
-                        metadata["llm_input_source_file_count"] = llm_input_source_files
-                        llm_input_source_ratio = (
-                            (llm_input_source_files / len(llm_input_files)) if llm_input_files else 0.0
-                        )
-                        metadata["llm_input_source_ratio"] = llm_input_source_ratio
-                        self.logger.info(
-                            "llm_input_selection",
-                            selected_files=metadata["llm_input_files"],
-                            selected_file_count=metadata["llm_input_file_count"],
-                            source_file_count=llm_input_source_files,
-                            source_file_ratio=round(llm_input_source_ratio, 3),
-                        )
-                        llm_code_review_findings = await self._analyze_code_with_llm(
-                            code_pack,
-                            effective_profile,
-                            selected_files=llm_input_files,
-                        )
-                        if llm_code_review_findings:
-                            metadata["analysis_layers"].append("llm_code_review")
-                            metadata["llm_code_review_used"] = True
-                            metadata["llm_code_review_findings"] = len(llm_code_review_findings)
-                except Exception as e:
-                    self.logger.warning("llm_code_review_failed", error=str(e))
-                    metadata["llm_code_review_error"] = str(e)
-
-        # Merge pattern scanner + LLM findings with deduplication (FR-1.3)
-        merged_security_findings = self._merge_findings_with_deduplication(
-            pattern_scanner_findings, llm_code_review_findings
-        )
-        findings.extend(merged_security_findings)
-        metadata["merged_security_findings"] = len(merged_security_findings)
-
-        # Layer 3: Basic pattern matching (TODOs, FIXMEs, etc.)
-        pattern_findings = self._scan_for_patterns(evidence_bundle)
-        if pattern_findings:
-            findings.extend(pattern_findings)
-            metadata["analysis_layers"].append("pattern_matching")
-
-        # Layer 4: PydanticAI-powered deep code quality analysis
-        if self.settings.enabled and evidence_bundle.git_evidence:
-            try:
-                skip_redundant_local_openai_pass = (
-                    not use_agentic
-                    and self.settings.protocol == LLMProtocolType.OPENAI
-                    and self._uses_local_openai_protocol()
-                    and bool(llm_code_review_findings)
-                )
-                if skip_redundant_local_openai_pass:
-                    metadata["pydantic_ai_quality_skipped"] = "local_openai_non_agentic_layer2_sufficient"
-                    code_findings = None
-                elif use_agentic and repo_path:
-                    code_findings = await self._run_agentic_analysis(
-                        evidence_bundle,
-                        effective_profile,
-                        repo_path,
-                        runtime=agentic_runtime,
-                    )
-                    latest_telemetry = getattr(self, "_last_agent_run_telemetry", {})
-                    if isinstance(latest_telemetry, dict):
-                        tool_efficiency = latest_telemetry.get("tool_efficiency")
-                        if isinstance(tool_efficiency, dict) and tool_efficiency:
-                            metadata["agentic_tool_efficiency"] = tool_efficiency
-                    metadata["analysis_layers"].append("agentic_investigation")
-                else:
-                    code_findings = await self._run_pydantic_ai_analysis(evidence_bundle, effective_profile)
-                    metadata["analysis_layers"].append("pydantic_ai_quality")
-
-                if code_findings:
-                    llm_findings = self._convert_code_findings(code_findings)
-                    findings.extend(llm_findings)
-                    metadata["llm_summary"] = {
-                        "score": code_findings.score,
-                        "confidence": code_findings.confidence,
-                        "reasoning": code_findings.reasoning,
-                        "files_analyzed": code_findings.files_analyzed,
-                        "tech_stack": code_findings.tech_stack,
-                    }
-                    metadata["score"] = code_findings.score
-                    metadata["confidence"] = code_findings.confidence
-            except Exception as e:
-                self.logger.warning("pydantic_ai_analysis_failed", error=str(e))
-                metadata["llm_error"] = str(e)
-                # Hard-cut: do not silently degrade AGENTIC runs to FAST mode.
-                if use_agentic:
-                    raise RuntimeError(f"agentic_analysis_failed: {e}") from e
-
-        metadata["total_findings"] = len(findings)
-        metadata["files_analyzed"] = len(evidence_bundle.git_evidence)
-        tool_usage = SkillExecutor.consume_usage()
-        if tool_usage:
-            metadata["tool_usage"] = tool_usage
-
-        return self._result(
-            agent_name=self.AGENT_NAME,
-            success=True,
-            findings=findings,
-            metadata=metadata,
-        )
-
-    def _normalize_evidence(self, evidence: EvidenceBundle | dict | AuditTask) -> EvidenceBundle | None:
-        """Normalize EvidenceBundle, AuditTask payloads, or dict payloads."""
-        if isinstance(evidence, EvidenceBundle):
-            return evidence
-        if isinstance(evidence, AuditTask):
-            payload = evidence.input_data
-            self._profile = payload.get("profile", {})
-            self._evidence_corpus = deserialize_evidence_corpus(payload.get("evidence_corpus"))
-            self._state_context = self._build_state_context_from_payload(payload)
-            bundle = payload.get("evidence_bundle") or payload.get("evidence")
-            if isinstance(bundle, EvidenceBundle):
-                return bundle
-            if isinstance(bundle, dict):
-                try:
-                    return EvidenceBundle.model_validate(bundle)
-                except Exception as exc:
-                    self.logger.debug("evidence_bundle_validation_failed", error=str(exc))
-                    return None
-        if isinstance(evidence, dict):
-            # Extract profile if present in dict format
-            self._profile = evidence.get("profile", {})
-            self._evidence_corpus = deserialize_evidence_corpus(evidence.get("evidence_corpus"))
-            self._state_context = self._build_state_context_from_payload(evidence)
-            bundle = evidence.get("evidence_bundle") or evidence.get("evidence")
-            if isinstance(bundle, EvidenceBundle):
-                return bundle
-            if isinstance(bundle, dict):
-                try:
-                    return EvidenceBundle.model_validate(bundle)
-                except Exception as exc:
-                    self.logger.debug("evidence_bundle_validation_failed", error=str(exc))
-                    return None
-        return None
-
-    @classmethod
-    def _build_state_context_from_payload(cls, payload: dict[str, Any]) -> dict[str, Any]:
-        """Normalize task payload context for downstream agentic planners."""
-        base_state_context = payload.get("state_context")
-        state_context = dict(base_state_context) if isinstance(base_state_context, dict) else {}
-
-        for key in (
-            "row_context",
-            "context",
-            "row",
-            "tool_get_row_context_output",
-            "retrieval_trace",
-        ):
-            value = payload.get(key)
-            if isinstance(value, dict) and key not in state_context:
-                state_context[key] = dict(value)
-
-        for key in (
-            "requirement_text",
-            "requirement_category",
-            "row_requirement_text",
-            "row_requirement_category",
-            "skills_needed",
-            "skills_needed_reason",
-        ):
-            if key not in state_context and key in payload:
-                state_context[key] = payload.get(key)
-
-        payload_interpretation = payload.get("requirement_interpretation")
-        if isinstance(payload_interpretation, dict) and "requirement_interpretation" not in state_context:
-            state_context["requirement_interpretation"] = dict(payload_interpretation)
-
-        resolved_interpretation = cls._extract_requirement_interpretation_from_state_context(state_context)
-        if resolved_interpretation and "requirement_interpretation" not in state_context:
-            state_context["requirement_interpretation"] = dict(resolved_interpretation)
-
-        return state_context
-
-    def _build_code_pack(self, repo_path: Path) -> CodeEvidencePack | None:
-        """Build CodeEvidencePack from the repository."""
-        try:
-            builder = CodePackBuilder(repo_path)
-            pack = builder.build()
-            self.logger.debug(
-                "code_pack_built_for_llm_review",
-                files=pack.total_files_included,
-                scanned=pack.total_files_scanned,
-            )
-            return pack
-        except Exception as e:
-            self.logger.warning("code_pack_build_failed", error=str(e))
-            return None
-
-    async def _analyze_code_with_llm(
-        self,
-        code_pack: CodeEvidencePack,
-        profile: dict[str, Any] | None = None,
-        selected_files: list[Any] | None = None,
-    ) -> list[dict[str, Any]]:
-        """Run semantic LLM review over selected files from CodeEvidencePack."""
-        findings: list[dict[str, Any]] = []
-        selected_files = selected_files or self._select_files_for_llm(code_pack)
-        file_summary = self._summarize_selected_files(selected_files)
-
-        # Format code pack for LLM prompt
-        code_context = self._format_code_pack_for_review(code_pack, files=selected_files)
-        if not code_context:
-            self.logger.debug("no_code_context_for_llm_review")
-            return findings
-        code_context_chars = len(code_context)
-        self.logger.info(
-            "llm_code_review_context_prepared",
-            code_context_chars=code_context_chars,
-            **file_summary,
-        )
-
-        # Build the analysis prompt
-        prompt = self._build_llm_code_review_prompt(code_context, profile)
-        prompt_chars = len(prompt)
-        self.logger.info(
-            "llm_code_review_prompt_prepared",
-            prompt_chars=prompt_chars,
-            approx_prompt_tokens=max(1, prompt_chars // 4),
-            profile_provided=bool(profile),
-        )
-
-        # Run LLM analysis
-        try:
-            start_time = time.monotonic()
-            llm_result = await self._run_pydantic_agent(
-                system_prompt=LLM_CODE_REVIEW_SYSTEM_PROMPT,
-                user_prompt=prompt,
-                result_type=CodeFindings,
-                complexity="standard",
-                deps=AuditDeps(
-                    profile=profile or {},
-                    repo_path=code_pack.repo_path,
-                ),
-            )
-            duration_ms = int((time.monotonic() - start_time) * 1000)
-
-            if llm_result:
-                # Convert CodeFindings issues to findings list
-                for issue in llm_result.issues:
-                    findings.append(
-                        {
-                            "type": f"security_{issue.category}"
-                            if "security" in issue.category.lower()
-                            else issue.category,
-                            "severity": issue.severity.lower(),
-                            "description": issue.description,
-                            "location": f"{issue.file_path}:{issue.line_number}"
-                            if issue.line_number
-                            else issue.file_path,
-                            "details": {
-                                "file_path": issue.file_path,
-                                "line_number": issue.line_number,
-                                "recommendation": issue.recommendation,
-                            },
-                            "source": "llm_code_review",
-                        }
-                    )
-
-                self.logger.info(
-                    "llm_code_review_complete",
-                    findings_count=len(findings),
-                    duration_ms=duration_ms,
-                    confidence=llm_result.confidence,
-                    code_context_chars=code_context_chars,
-                    prompt_chars=prompt_chars,
-                    **file_summary,
-                )
-
-                SkillExecutor.record_tool_usage(
-                    {
-                        "tool": "llm_code_review",
-                        "agent": "CodeAnalysisAgent",
-                        "files_analyzed": code_pack.total_files_included,
-                        "findings_count": len(findings),
-                        "duration_ms": duration_ms,
-                        "confidence": llm_result.confidence,
-                        "success": True,
-                    }
-                )
-
-        except Exception as e:
-            self.logger.warning(
-                "llm_code_review_analysis_failed",
-                error=str(e),
-                code_context_chars=code_context_chars,
-                prompt_chars=prompt_chars,
-                **file_summary,
-            )
-            SkillExecutor.record_tool_usage(
-                {
-                    "tool": "llm_code_review",
-                    "agent": "CodeAnalysisAgent",
-                    "files_analyzed": code_pack.total_files_included,
-                    "findings_count": 0,
-                    "success": False,
-                    "error": str(e),
-                }
-            )
-
-        return findings
-
-    def _format_code_pack_for_review(
-        self,
-        code_pack: CodeEvidencePack,
-        files: list[Any] | None = None,
-    ) -> str:
-        """Format CodeEvidencePack for LLM code review prompt."""
-        selected_files = files or self._select_files_for_llm(code_pack)
-        return format_code_pack_for_review(code_pack, selected_files)
-
-    def _format_code_pack_for_review_with_files(
-        self,
-        code_pack: CodeEvidencePack,
-        files: list[Any],
-    ) -> str:
-        """Format selected CodeEvidencePack files for LLM code review prompt."""
-        return format_code_pack_for_review(code_pack, files)
-
-    @staticmethod
-    def _summarize_selected_files(files: list[Any]) -> dict[str, Any]:
-        """Summarize selected files for LLM request observability."""
-        return summarize_selected_files(files)
-
-    def _build_llm_code_review_prompt(
-        self,
-        code_context: str,
-        profile: dict[str, Any] | None = None,
-    ) -> str:
-        """Build the prompt for LLM code review."""
-        return build_llm_code_review_prompt(code_context, profile)
-
-    def _merge_findings_with_deduplication(
-        self,
-        pattern_findings: list[dict[str, Any]],
-        llm_findings: list[dict[str, Any]],
-    ) -> list[dict[str, Any]]:
-        """Merge findings from pattern scanner and LLM with deduplication."""
-        return merge_findings_with_deduplication(
-            pattern_findings,
-            llm_findings,
-            logger=self.logger,
-        )
-
-    def _convert_code_findings(self, code_findings: CodeFindings) -> list[dict[str, Any]]:
-        """Convert typed CodeFindings output to AgentResult finding dictionaries."""
-        findings: list[dict[str, Any]] = []
-
-        # Convert issues to findings
-        for issue in code_findings.issues:
-            findings.append(
-                {
-                    "type": issue.category,
-                    "severity": issue.severity,
-                    "description": issue.description,
-                    "location": issue.file_path,
-                    "line_number": issue.line_number,
-                    "recommendation": issue.recommendation,
-                    "source": "pydantic_ai_analysis",
-                }
-            )
-
-        # Convert patterns to findings
-        for pattern in code_findings.patterns:
-            findings.append(
-                {
-                    "type": "pattern",
-                    "severity": "info" if pattern.is_positive else "medium",
-                    "description": f"{'Good practice' if pattern.is_positive else 'Anti-pattern'}: {pattern.name}",
-                    "details": {
-                        "occurrences": pattern.occurrences,
-                        "is_positive": pattern.is_positive,
-                        "description": pattern.description,
-                        "examples": pattern.examples,
-                    },
-                    "source": "pydantic_ai_analysis",
-                }
-            )
-
-        return findings
-
-    def _get_repo_path(
-        self,
-        evidence: EvidenceBundle,
-        profile: dict[str, Any] | None,
-    ) -> Path | None:
-        """Extract repository path from evidence bundle or profile."""
-        return get_repo_path(evidence, profile, logger=self.logger)
-
-    async def _scan_security_patterns(self, repo_path: Path) -> list[dict[str, Any]]:
-        """Scan repository for scoped security patterns."""
-        findings: list[dict[str, Any]] = []
-
-        try:
-            scanner = SecurityPatternScanner(repo_path)
-            start = time.monotonic()
-            results = scanner.scan(SECURITY_PATTERNS)
-            duration_ms = int((time.monotonic() - start) * 1000)
-
-            for result in results:
-                findings.append(
-                    {
-                        "type": f"security_{result.pattern_name}",
-                        "severity": result.severity.lower(),
-                        "description": f"Potential security issue: {result.description}",
-                        "location": f"{result.file_path}:{result.line_number}",
-                        "details": {
-                            "file_path": result.file_path,
-                            "line_number": result.line_number,
-                            "line_content": result.line_content,
-                            "match_text": result.match_text,
-                        },
-                        "source": "pattern_scanner",
-                    }
-                )
-
-            self.logger.info(
-                "code_agent_security_scan_complete",
-                repo_path=str(repo_path),
-                findings_count=len(findings),
-            )
-            SkillExecutor.record_tool_usage(
-                {
-                    "tool": "security_pattern_scanner",
-                    "agent": "CodeAnalysisAgent",
-                    "repo_path": str(repo_path),
-                    "pattern_count": len(SECURITY_PATTERNS),
-                    "findings_count": len(findings),
-                    "duration_ms": duration_ms,
-                    "success": True,
-                }
-            )
-
-        except Exception as e:
-            self.logger.warning("code_agent_pattern_scan_failed", error=str(e))
-            SkillExecutor.record_tool_usage(
-                {
-                    "tool": "security_pattern_scanner",
-                    "agent": "CodeAnalysisAgent",
-                    "repo_path": str(repo_path),
-                    "pattern_count": len(SECURITY_PATTERNS),
-                    "findings_count": 0,
-                    "duration_ms": 0,
-                    "success": False,
-                    "error": str(e),
-                }
-            )
-
-        return findings
-
-    def _scan_for_patterns(self, evidence: EvidenceBundle) -> list[dict[str, Any]]:
-        """Scan git evidence for common code patterns."""
-        return scan_for_patterns(evidence)
-
-    def _prepare_code_samples(
-        self,
-        evidence: EvidenceBundle,
-        max_files: int = 5,
-        max_chars_per_file: int = 3000,
-    ) -> str:
-        """Prepare code samples for LLM analysis."""
-        return prepare_code_samples(
-            evidence=evidence,
-            max_files=max_files,
-            max_chars_per_file=max_chars_per_file,
-        )