verdity 0.2.0__py3-none-any.whl

verdity/__init__.py

@@ -0,0 +1,6 @@
+"""
+Verdity — AI Pull Request Reviewer, Production Agent System
+Root package.
+"""
+
+__version__ = "0.2.0"

verdity/agents/__init__.py

@@ -0,0 +1,17 @@
+"""
+Verdity specialist agents package.
+"""
+
+from verdity.agents.base import BaseSpecialistAgent
+from verdity.agents.code_quality import CodeQualityAgent
+from verdity.agents.documentation import DocumentationAgent
+from verdity.agents.security import SecurityAgent
+from verdity.agents.testing import TestingAgent
+
+__all__ = [
+    "BaseSpecialistAgent",
+    "CodeQualityAgent",
+    "DocumentationAgent",
+    "SecurityAgent",
+    "TestingAgent",
+]

verdity/agents/base.py

@@ -0,0 +1,105 @@
+"""
+Base specialist agent — shared boilerplate for all Verdity specialist agents.
+
+Eliminates duplication across security, code_quality, testing, and documentation
+agents by providing common run orchestration, token metering, and audit logging.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+from abc import ABC, abstractmethod
+
+from verdity.audit_store import AuditStore
+from verdity.schemas import (
+    ConcernType,
+    Finding,
+    SpecialistContext,
+    SpecialistResponse,
+)
+from verdity.semantic_index import SemanticIndex
+from verdity.token_economics import TokenEconomicsService
+
+logger = logging.getLogger(__name__)
+
+
+class BaseSpecialistAgent(ABC):
+    """Abstract base for all specialist agents. Handles metering and audit."""
+
+    AGENT_VERSION: str = "base-agent@0.0.0"
+    SPECIALIST_NAME: str = "base"
+    CONCERN_TYPE: ConcernType = ConcernType.SECURITY
+
+    # Subclasses override these for token estimation
+    _input_tokens_per_finding: int = 300
+    _output_tokens_per_finding: int = 50
+
+    async def run(
+        self,
+        ctx: SpecialistContext,
+        semantic_index: SemanticIndex,
+        token_economics: TokenEconomicsService,
+        audit_store: AuditStore,
+    ) -> SpecialistResponse:
+        """
+        Template method: scan → record tokens → audit-log findings → return.
+        Subclasses implement `_scan()` for the actual analysis.
+        """
+        findings = await self._scan(ctx, semantic_index)
+
+        input_tokens = len(findings) * self._input_tokens_per_finding
+        output_tokens = len(findings) * self._output_tokens_per_finding
+
+        await token_economics.record_call(
+            review_run_id=ctx.review_run_id,
+            agent_name=self.AGENT_VERSION,
+            model=f"{self.SPECIALIST_NAME}/dev",
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            repo_owner=ctx.repo_owner,
+            repo_name=ctx.repo_name,
+            org=ctx.repo_owner,
+        )
+
+        for finding in findings:
+            await audit_store.append(
+                event_type="finding.created",
+                entity_type="finding",
+                entity_id=str(finding.finding_id),
+                payload={
+                    "concern": finding.concern.value,
+                    "severity": finding.severity.value,
+                    "file": finding.file,
+                    "summary": finding.summary,
+                    "confidence": finding.confidence,
+                    "agent_version": self.AGENT_VERSION,
+                },
+                related_run_id=ctx.review_run_id,
+            )
+
+        logger.info(
+            "%s run %s: %d findings",
+            self.SPECIALIST_NAME, ctx.review_run_id, len(findings),
+        )
+        return SpecialistResponse(
+            review_run_id=ctx.review_run_id,
+            specialist=self.SPECIALIST_NAME,
+            status="complete",
+            findings=findings,
+            tokens_used={"input": input_tokens, "output": output_tokens},
+            cost_usd=0.0,
+        )
+
+    @abstractmethod
+    async def _scan(
+        self,
+        ctx: SpecialistContext,
+        semantic_index: SemanticIndex,
+    ) -> list[Finding]:
+        """Subclass implements the actual scan logic."""
+        ...
+
+    @staticmethod
+    def _prompt_hash(*parts: str) -> str:
+        return "sha256:" + hashlib.sha256("|".join(parts).encode()).hexdigest()[:16]

verdity/agents/code_quality.py

@@ -0,0 +1,92 @@
+"""
+Code Quality Specialist Agent.
+
+Reviews PR diffs for code style, maintainability, and structural issues.
+Produces schema-valid findings with deterministic confidence scores.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from verdity.agents.base import BaseSpecialistAgent
+from verdity.schemas import (
+    ConcernType,
+    EvidenceItem,
+    Finding,
+    SpecialistContext,
+    Severity,
+)
+from verdity.semantic_index import SemanticIndex
+
+logger = logging.getLogger(__name__)
+
+# ── Code quality patterns (deterministic rules) ──────────────────────
+
+QUALITY_PATTERNS: list[tuple[str, str, str, str]] = [
+    # (name, pattern, severity, explanation)
+    ("long_function", "def .*\\(.*\\):\\n.{200,}", "medium", "Function may be too long — consider refactoring"),
+    ("deep_nesting", "    {5,}", "low", "Deep nesting reduces readability — consider early returns"),
+    ("todo_comment", "TODO", "info", "TODO comment found — track for follow-up"),
+    ("fixme_comment", "FIXME", "low", "FIXME comment found — should be addressed before merge"),
+    ("magic_number", "= \\d{4,}", "low", "Magic number — consider a named constant"),
+    ("bare_except", "except:", "medium", "Bare except catches all exceptions — specify exception types"),
+    ("global_import", "from .* import \\*", "high", "Wildcard import pollutes namespace — import names explicitly"),
+    ("assert_in_code", "assert ", "medium", "Assert statement in production code — removes on optimize"),
+    ("print_statement", "print\\(", "low", "Debug print statement — remove before merge"),
+]
+
+
+class CodeQualityAgent(BaseSpecialistAgent):
+    """Code quality specialist agent for Verdity."""
+
+    AGENT_VERSION = "code-quality-agent@0.1.0"
+    SPECIALIST_NAME = "code_quality"
+    CONCERN_TYPE = ConcernType.CODE_QUALITY
+    _input_tokens_per_finding = 300
+    _output_tokens_per_finding = 50
+
+    async def _scan(
+        self,
+        ctx: SpecialistContext,
+        semantic_index: SemanticIndex,
+    ) -> list[Finding]:
+        findings: list[Finding] = []
+
+        for file_info in ctx.diff_files:
+            path = file_info.get("path", "")
+            content = file_info.get("content", "")
+            additions = file_info.get("additions", "")
+            scan_text = additions if additions else content
+
+            for name, pattern, severity, explanation in QUALITY_PATTERNS:
+                if pattern.lower() in scan_text.lower():
+                    lines = scan_text.split("\n")
+                    for i, line in enumerate(lines, start=1):
+                        if pattern.lower() in line.lower():
+                            findings.append(Finding(
+                                concern=ConcernType.CODE_QUALITY,
+                                severity=Severity(severity),
+                                file=path,
+                                line_start=i,
+                                line_end=i,
+                                summary=f"{name.replace('_', ' ').title()} detected",
+                                explanation=f"{explanation} at {path}:{i}",
+                                suggested_fix_diff=self._suggested_fix(name),
+                                confidence=0.6 if severity == "info" else 0.7,
+                                evidence=[EvidenceItem(tool="code_quality_linter", query=pattern, result=name)],
+                                agent_version=self.AGENT_VERSION,
+                                prompt_hash=self._prompt_hash(name, path, str(i)),
+                            ))
+                            break
+
+        return findings
+
+    @staticmethod
+    def _suggested_fix(name: str) -> str | None:
+        fixes = {
+            "bare_except": "- except:\n+ except Exception as e:\n    logger.error(...)",
+            "global_import": "- from module import *\n+ from module import specific_name",
+            "print_statement": "- print(x)\n+ logging.debug(%r, x)",
+        }
+        return fixes.get(name)

verdity/agents/documentation.py

@@ -0,0 +1,74 @@
+"""
+Documentation Specialist Agent.
+
+Reviews PR diffs for documentation quality and completeness.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from verdity.agents.base import BaseSpecialistAgent
+from verdity.schemas import (
+    ConcernType,
+    EvidenceItem,
+    Finding,
+    SpecialistContext,
+    Severity,
+)
+from verdity.semantic_index import SemanticIndex
+
+logger = logging.getLogger(__name__)
+
+DOC_PATTERNS: list[tuple[str, str, str, str]] = [
+    ("missing_docstring", "def ", "info", "Function added — verify docstring coverage"),
+    ("missing_type_hints", "def ", "low", "Function may lack type hints"),
+    ("changelog_entry", "CHANGELOG", "info", "Changelog entry detected — verify format"),
+    ("breaking_change", "breaking change", "medium", "Potential breaking change noted — verify migration docs"),
+]
+
+
+class DocumentationAgent(BaseSpecialistAgent):
+    """Documentation specialist agent for Verdity."""
+
+    AGENT_VERSION = "docs-agent@0.1.0"
+    SPECIALIST_NAME = "documentation"
+    CONCERN_TYPE = ConcernType.DOCUMENTATION
+    _input_tokens_per_finding = 150
+    _output_tokens_per_finding = 20
+
+    async def _scan(
+        self,
+        ctx: SpecialistContext,
+        semantic_index: SemanticIndex,
+    ) -> list[Finding]:
+        findings: list[Finding] = []
+
+        for file_info in ctx.diff_files:
+            path = file_info.get("path", "")
+            content = file_info.get("content", "")
+            additions = file_info.get("additions", "")
+            scan_text = additions if additions else content
+
+            for name, pattern, severity, explanation in DOC_PATTERNS:
+                if pattern.lower() in scan_text.lower():
+                    lines = scan_text.split("\n")
+                    for i, line in enumerate(lines, start=1):
+                        if pattern.lower() in line.lower():
+                            findings.append(Finding(
+                                concern=ConcernType.DOCUMENTATION,
+                                severity=Severity(severity),
+                                file=path,
+                                line_start=i,
+                                line_end=i,
+                                summary=f"{name.replace('_', ' ').title()}",
+                                explanation=f"{explanation} at {path}:{i}",
+                                suggested_fix_diff=None,
+                                confidence=0.4 if severity == "info" else 0.55,
+                                evidence=[EvidenceItem(tool="docs_analyzer", query=pattern, result=name)],
+                                agent_version=self.AGENT_VERSION,
+                                prompt_hash=self._prompt_hash(name, path, str(i)),
+                            ))
+                            break
+
+        return findings

verdity/agents/security.py

@@ -0,0 +1,274 @@
+"""
+Security Specialist Agent.
+
+Produces structured, evidence-backed security findings for PR diffs.
+Tools available: semantic_search, secret_scanner, cve_lookup (mocked in dev).
+
+Non-negotiable constraints satisfied:
+  - #4: Uses the shared SemanticIndex (no private vector store)
+  - #5: Confidence computed by deterministic post-processing, never raw LLM self-report
+  - #8: Every model/tool call metered through TokenEconomicsService
+  - #9: Every finding logged to Audit Store
+"""
+
+from __future__ import annotations
+
+import logging
+
+from verdity.agents.base import BaseSpecialistAgent
+from verdity.schemas import (
+    ConcernType,
+    EvidenceItem,
+    Finding,
+    Severity,
+    SpecialistContext,
+)
+from verdity.semantic_index import SemanticIndex
+
+logger = logging.getLogger(__name__)
+
+# ── Security scan patterns (deterministic rules, no LLM needed for these) ──
+
+_SECRET_PATTERNS: list[tuple[str, str, str]] = [
+    # (name, regex-like substring, severity)
+    ("AWS_ACCESS_KEY", "aws_access_key", "high"),
+    ("AWS_SECRET_KEY", "aws_secret_key", "high"),
+    ("PRIVATE_KEY", "-----BEGIN.*PRIVATE KEY-----", "critical"),
+    ("GITHUB_TOKEN", "ghp_", "high"),
+    ("GITHUB_TOKEN_ALT", "github_pat_", "high"),
+    ("SLACK_TOKEN", "xoxb-", "medium"),
+    ("SLACK_TOKEN_USER", "xoxp-", "medium"),
+    ("JWT_SECRET", "jwtSecret", "high"),
+    ("API_KEY_ASSIGN", '= "sk-', "high"),
+    ("HARDCODED_PASSWORD", "password = '", "high"),
+]
+
+_CWE_MAPPING: dict[str, str] = {
+    "AWS_ACCESS_KEY": "CWE-798 (Use of Hard-coded Credentials)",
+    "PRIVATE_KEY": "CWE-321 (Use of Hard-coded Cryptographic Key)",
+    "GITHUB_TOKEN": "CWE-798",
+    "GITHUB_TOKEN_ALT": "CWE-798",
+    "SLACK_TOKEN": "CWE-798",
+    "JWT_SECRET": "CWE-798",
+    "API_KEY_ASSIGN": "CWE-798",
+    "HARDCODED_PASSWORD": "CWE-798",
+}
+
+
+class SecurityAgent(BaseSpecialistAgent):
+    """
+    Security specialist agent for Verdity.
+
+    Performs deterministic static analysis + semantic search to produce
+    security findings with cited evidence and computed confidence scores.
+    """
+
+    AGENT_VERSION = "security-agent@0.1.0"
+    SPECIALIST_NAME = "security"
+    CONCERN_TYPE = ConcernType.SECURITY
+    _input_tokens_per_finding = 500
+    _output_tokens_per_finding = 50
+
+    async def _scan(
+        self,
+        ctx: SpecialistContext,
+        semantic_index: SemanticIndex,
+    ) -> list[Finding]:
+        findings: list[Finding] = []
+
+        # ── Pass 1: Deterministic rule-based scans (no LLM cost) ──────
+        rule_findings = self._scan_for_secrets(ctx.diff_files)
+        findings.extend(rule_findings)
+
+        # ── Pass 2: Semantic search for security-relevant patterns ────
+        security_queries = [
+            "authentication", "authorization", "session", "token",
+            "password", "crypto", "hash", "encryption", "SQL injection",
+            "XSS", "CSRF", "deserialization", "file upload",
+        ]
+        semantic_findings = await self._semantic_security_search(
+            ctx=ctx,
+            queries=security_queries,
+            semantic_index=semantic_index,
+        )
+        findings.extend(semantic_findings)
+
+        # ── Pass 3: Diff-aware analysis (check added lines specifically) ─
+        diff_findings = self._scan_diff_for_vulnerabilities(ctx.diff_files)
+        findings.extend(diff_findings)
+
+        return findings
+
+    # ── Rule-Based Scans ──────────────────────────────────────────────
+
+    def _scan_for_secrets(self, diff_files: list[dict]) -> list[Finding]:
+        """Deterministic scan for hard-coded secrets in diff content."""
+        findings: list[Finding] = []
+        for file_info in diff_files:
+            path = file_info.get("path", "")
+            content = file_info.get("content", "")
+            additions = file_info.get("additions", "")
+
+            scan_text = additions if additions else content
+
+            for pattern_name, pattern_str, severity_str in _SECRET_PATTERNS:
+                if pattern_str.lower() in scan_text.lower():
+                    lines = scan_text.split("\n")
+                    for i, line in enumerate(lines, start=1):
+                        if pattern_str.lower() in line.lower():
+                            severity = self._str_to_severity(severity_str)
+                            cwe = _CWE_MAPPING.get(pattern_name, "CWE-798")
+                            findings.append(Finding(
+                                concern=ConcernType.SECURITY,
+                                severity=severity,
+                                file=path,
+                                line_start=i,
+                                line_end=i,
+                                summary=f"Potential {pattern_name.replace('_', ' ')} detected",
+                                explanation=f"Pattern '{pattern_str}' found in {path}:{i}. "
+                                            f"This may be a hard-coded credential. {cwe}",
+                                suggested_fix_diff=None,
+                                confidence=self._compute_secret_confidence(pattern_name, line),
+                                evidence=[EvidenceItem(
+                                    tool="secret_scanner",
+                                    result=cwe,
+                                    query=pattern_str,
+                                )],
+                                agent_version=self.AGENT_VERSION,
+                                prompt_hash=self._prompt_hash("secret_scan", path, str(i)),
+                            ))
+                            break
+        return findings
+
+    def _scan_diff_for_vulnerabilities(self, diff_files: list[dict]) -> list[Finding]:
+        """Scan diff content for common vulnerability patterns."""
+        findings: list[Finding] = []
+        vuln_patterns: list[tuple[str, str, str, str]] = [
+            ("sql_injection", "f\"SELECT", "high", "Potential SQL injection via f-string"),
+            ("sql_injection2", "' + request", "high", "Potential SQL injection via string concat"),
+            ("eval_usage", "eval(", "critical", "Use of eval() — potential code injection"),
+            ("exec_usage", "exec(", "critical", "Use of exec() — potential code injection"),
+            ("shell_injection", "subprocess.call.*shell=True", "critical", "Shell injection risk"),
+            ("os_system", "os.system(", "high", "os.system() — potential command injection"),
+            ("pickle_load", "pickle.load", "high", "Unsafe deserialization via pickle"),
+            ("yaml_unsafe", "yaml.load(", "medium", "Unsafe YAML load — use yaml.safe_load"),
+            ("path_traversal", "../", "medium", "Potential path traversal — validate input"),
+            ("weak_hash", "md5(", "medium", "Weak hash function — use SHA-256 or stronger"),
+            ("insecure_random", "random.randint", "low", "Cryptographically weak random"),
+        ]
+
+        for file_info in diff_files:
+            path = file_info.get("path", "")
+            content = file_info.get("content", "")
+            additions = file_info.get("additions", "")
+            scan_text = additions if additions else content
+
+            for name, pattern, severity, explanation in vuln_patterns:
+                if pattern.lower() in scan_text.lower():
+                    lines = scan_text.split("\n")
+                    for i, line in enumerate(lines, start=1):
+                        if pattern.lower() in line.lower():
+                            findings.append(Finding(
+                                concern=ConcernType.SECURITY,
+                                severity=self._str_to_severity(severity),
+                                file=path,
+                                line_start=i,
+                                line_end=i,
+                                summary=f"{name.replace('_', ' ').title()} detected",
+                                explanation=f"{explanation} at {path}:{i}",
+                                suggested_fix_diff=self._suggested_fix(name),
+                                confidence=0.75 if severity in ("high", "critical") else 0.55,
+                                evidence=[EvidenceItem(
+                                    tool="static_analyzer",
+                                    result=name,
+                                    query=pattern,
+                                )],
+                                agent_version=self.AGENT_VERSION,
+                                prompt_hash=self._prompt_hash("vuln_scan", path, str(i)),
+                            ))
+                            break
+        return findings
+
+    # ── Semantic Security Search ──────────────────────────────────────
+
+    async def _semantic_security_search(
+        self,
+        *,
+        ctx: SpecialistContext,
+        queries: list[str],
+        semantic_index: SemanticIndex,
+    ) -> list[Finding]:
+        findings: list[Finding] = []
+        diff_paths = {fi.get("path", "") for fi in ctx.diff_files}
+
+        for query in queries:
+            try:
+                results = await semantic_index.search_by_text(
+                    f"{ctx.repo_owner}/{ctx.repo_name}", query, limit=3,
+                )
+                for chunk in results:
+                    if chunk["file_path"] not in diff_paths:
+                        continue
+                    content = chunk["content"]
+                    security_keywords = ["auth", "token", "password", "secret", "key", "session"]
+                    if any(kw in content.lower() for kw in security_keywords):
+                        findings.append(Finding(
+                            concern=ConcernType.SECURITY,
+                            severity=self._str_to_severity("medium"),
+                            file=chunk["file_path"],
+                            line_start=chunk["start_line"],
+                            line_end=chunk["end_line"],
+                            summary=f"Security-relevant code near search term: '{query}'",
+                            explanation=(
+                                f"File {chunk['file_path']} contains both '{query}' and "
+                                f"security keywords. Review for proper handling."
+                            ),
+                            suggested_fix_diff=None,
+                            confidence=0.45,
+                            evidence=[EvidenceItem(
+                                tool="semantic_search",
+                                query=query,
+                                result=f"matched at {chunk['file_path']}:{chunk['start_line']}",
+                            )],
+                            agent_version=self.AGENT_VERSION,
+                            prompt_hash=self._prompt_hash("semantic_search", query, chunk["file_path"]),
+                        ))
+            except Exception as exc:
+                logger.debug("Semantic search for '%s' failed: %s", query, exc)
+
+        return findings
+
+    # ── Confidence Computation (deterministic, per Orchestration doc §4) ─
+
+    def _compute_secret_confidence(self, pattern_name: str, line: str) -> float:
+        if pattern_name in ("PRIVATE_KEY",):
+            base_confidence = 0.95
+        elif pattern_name in ("AWS_ACCESS_KEY", "AWS_SECRET_KEY"):
+            base_confidence = 0.90
+        else:
+            base_confidence = 0.85
+
+        stripped = line.strip()
+        if stripped.startswith("#") or stripped.startswith("//") or stripped.startswith("*"):
+            base_confidence = max(0.1, base_confidence - 0.3)
+
+        return round(base_confidence, 2)
+
+    # ── Helpers ───────────────────────────────────────────────────────
+
+    @staticmethod
+    def _str_to_severity(s: str) -> "Severity":
+        from verdity.schemas import Severity
+        return Severity(s.lower())
+
+    @staticmethod
+    def _suggested_fix(vuln_name: str) -> str | None:
+        fixes: dict[str, str] = {
+            "sql_injection": "- cursor.execute(f\"SELECT ...\")\n+ cursor.execute(\"SELECT ... WHERE id = %s\", (user_id,))",
+            "eval_usage": "- result = eval(user_input)\n+ result = ast.literal_eval(user_input)  # or a safer alternative",
+            "exec_usage": "- exec(user_code)\n+ # Avoid exec; use a sandboxed environment or pre-compiled functions",
+            "pickle_load": "- data = pickle.load(f)\n+ data = json.load(f)  # or use a safe deserializer",
+            "yaml_unsafe": "- yaml.load(stream)\n+ yaml.safe_load(stream)",
+            "weak_hash": "- hashlib.md5(data)\n+ hashlib.sha256(data)",
+        }
+        return fixes.get(vuln_name)

verdity/agents/testing.py

@@ -0,0 +1,74 @@
+"""
+Testing Specialist Agent.
+
+Reviews PR diffs for test coverage gaps and testing best practices.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from verdity.agents.base import BaseSpecialistAgent
+from verdity.schemas import (
+    ConcernType,
+    EvidenceItem,
+    Finding,
+    SpecialistContext,
+    Severity,
+)
+from verdity.semantic_index import SemanticIndex
+
+logger = logging.getLogger(__name__)
+
+TEST_PATTERNS: list[tuple[str, str, str, str]] = [
+    ("no_test_for_function", "def test_", "info", "Test function added — verify implementation coverage"),
+    ("untested_branch", "    pass", "medium", "Empty branch (pass) may indicate untested path"),
+    ("mock_usage", "mock.patch", "info", "Mock usage detected — verify mock scope is appropriate"),
+    ("assert_no_message", "assert ", "low", "Assertion found — verify test covers behavior not messages"),
+]
+
+
+class TestingAgent(BaseSpecialistAgent):
+    """Testing specialist agent for Verdity."""
+
+    AGENT_VERSION = "testing-agent@0.1.0"
+    SPECIALIST_NAME = "testing"
+    CONCERN_TYPE = ConcernType.TESTING
+    _input_tokens_per_finding = 200
+    _output_tokens_per_finding = 30
+
+    async def _scan(
+        self,
+        ctx: SpecialistContext,
+        semantic_index: SemanticIndex,
+    ) -> list[Finding]:
+        findings: list[Finding] = []
+
+        for file_info in ctx.diff_files:
+            path = file_info.get("path", "")
+            additions = file_info.get("additions", "")
+            if not additions:
+                continue
+
+            for name, pattern, severity, explanation in TEST_PATTERNS:
+                if pattern.lower() in additions.lower():
+                    lines = additions.split("\n")
+                    for i, line in enumerate(lines, start=1):
+                        if pattern.lower() in line.lower():
+                            findings.append(Finding(
+                                concern=ConcernType.TESTING,
+                                severity=Severity(severity),
+                                file=path,
+                                line_start=i,
+                                line_end=i,
+                                summary=f"{name.replace('_', ' ').title()}",
+                                explanation=f"{explanation} at {path}:{i}",
+                                suggested_fix_diff=None,
+                                confidence=0.5 if severity == "info" else 0.65,
+                                evidence=[EvidenceItem(tool="test_analyzer", query=pattern, result=name)],
+                                agent_version=self.AGENT_VERSION,
+                                prompt_hash=self._prompt_hash(name, path, str(i)),
+                            ))
+                            break
+
+        return findings