comit-cli 1.0.0__py3-none-any.whl

comit/git.py

@@ -0,0 +1,281 @@
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+from pathlib import Path
+from typing import Optional, List, Tuple
+
+from comit.commit.context import ChangedFile, DiffStat, CommitContext
+
+
+class GitError(Exception):
+    pass
+
+
+class GitNotInstalledError(GitError):
+    pass
+
+
+class NotAGitRepositoryError(GitError):
+    pass
+
+
+class NoStagedChangesError(GitError):
+    pass
+
+
+class GitCommitError(GitError):
+    pass
+
+
+def _run_git_command(args: List[str], cwd: Optional[Path | str] = None) -> subprocess.CompletedProcess[str]:
+    cmd = ["git"] + args
+    try:
+        return subprocess.run(
+            cmd,
+            cwd=str(cwd) if cwd else None,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            shell=False,
+            check=False,
+        )
+    except FileNotFoundError as exc:
+        raise GitNotInstalledError(
+            "Git is not installed or not found in system PATH. Please install Git to use Comit."
+        ) from exc
+
+
+def is_git_repository(cwd: Optional[Path | str] = None) -> bool:
+    res = _run_git_command(["rev-parse", "--is-inside-work-tree"], cwd=cwd)
+    return res.returncode == 0 and res.stdout.strip() == "true"
+
+
+def get_repository_name(cwd: Optional[Path | str] = None) -> str:
+    if not is_git_repository(cwd):
+        target_dir = Path(cwd).resolve() if cwd else Path.cwd()
+        return target_dir.name or "repository"
+
+    res = _run_git_command(["rev-parse", "--show-toplevel"], cwd=cwd)
+    if res.returncode == 0 and res.stdout.strip():
+        top_dir = Path(res.stdout.strip()).resolve()
+        return top_dir.name
+
+    target_dir = Path(cwd).resolve() if cwd else Path.cwd()
+    return target_dir.name or "repository"
+
+
+def get_staged_diff(cwd: Optional[Path | str] = None) -> str:
+    if not is_git_repository(cwd):
+        raise NotAGitRepositoryError("Not a Git repository.")
+
+    res = _run_git_command(["diff", "--cached"], cwd=cwd)
+    if res.returncode != 0:
+        raise GitError(f"Failed to get staged diff: {res.stderr.strip()}")
+    return res.stdout.strip()
+
+
+def get_staged_changed_files(cwd: Optional[Path | str] = None) -> List[ChangedFile]:
+    if not is_git_repository(cwd):
+        raise NotAGitRepositoryError("Not a Git repository.")
+
+    res = _run_git_command(["diff", "--cached", "--name-status"], cwd=cwd)
+    if res.returncode != 0:
+        return []
+
+    changed_files: List[ChangedFile] = []
+    for line in res.stdout.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        parts = line.split("\t")
+        if len(parts) >= 3:
+            raw_status = parts[0].strip()
+            status_code = raw_status[0].upper() if raw_status else "M"
+            old_path = parts[1].strip()
+            new_path = parts[2].strip()
+            changed_files.append(ChangedFile(path=new_path, status=status_code, old_path=old_path))
+        elif len(parts) == 2:
+            raw_status = parts[0].strip()
+            status_code = raw_status[0].upper() if raw_status else "M"
+            path = parts[1].strip()
+            changed_files.append(ChangedFile(path=path, status=status_code))
+    return changed_files
+
+
+def get_staged_file_size(path: str, cwd: Optional[Path | str] = None) -> int:
+    if not is_git_repository(cwd):
+        return 0
+
+    res = _run_git_command(["cat-file", "-s", f":{path}"], cwd=cwd)
+    if res.returncode == 0 and res.stdout.strip().isdigit():
+        return int(res.stdout.strip())
+
+    try:
+        target = Path(cwd) / path if cwd else Path(path)
+        if target.is_file():
+            return target.stat().st_size
+    except Exception:
+        pass
+    return 0
+
+
+def get_diff_stat(cwd: Optional[Path | str] = None) -> DiffStat:
+    if not is_git_repository(cwd):
+        raise NotAGitRepositoryError("Not a Git repository.")
+
+    res = _run_git_command(["diff", "--cached", "--shortstat"], cwd=cwd)
+    if res.returncode != 0 or not res.stdout.strip():
+        return DiffStat()
+
+    text = res.stdout.strip()
+    files_changed = 0
+    insertions = 0
+    deletions = 0
+
+    m_files = re.search(r"(\d+)\s+file", text)
+    if m_files:
+        files_changed = int(m_files.group(1))
+
+    m_ins = re.search(r"(\d+)\s+insertion", text)
+    if m_ins:
+        insertions = int(m_ins.group(1))
+
+    m_del = re.search(r"(\d+)\s+deletion", text)
+    if m_del:
+        deletions = int(m_del.group(1))
+
+    return DiffStat(
+        files_changed=files_changed,
+        insertions=insertions,
+        deletions=deletions,
+        summary_text=text,
+    )
+
+
+def get_recent_commits(count: int = 5, cwd: Optional[Path | str] = None) -> List[str]:
+    if not is_git_repository(cwd):
+        raise NotAGitRepositoryError("Not a Git repository.")
+
+    res = _run_git_command(["log", f"-{count}", "--pretty=format:%s"], cwd=cwd)
+    if res.returncode != 0:
+        return []
+    
+    output = res.stdout.strip()
+    if not output:
+        return []
+    return [line.strip() for line in output.splitlines() if line.strip()]
+
+
+def get_git_status_short(cwd: Optional[Path | str] = None) -> str:
+    if not is_git_repository(cwd):
+        raise NotAGitRepositoryError("Not a Git repository.")
+
+    res = _run_git_command(["status", "--short"], cwd=cwd)
+    return res.stdout.strip()
+
+
+def create_commit(message: str, cwd: Optional[Path | str] = None) -> Tuple[bool, str]:
+    if not is_git_repository(cwd):
+        raise NotAGitRepositoryError("Not a Git repository.")
+
+    clean_message = message.strip()
+    if not clean_message:
+        raise GitCommitError("Cannot create commit with an empty commit message.")
+
+    res = _run_git_command(["commit", "-m", clean_message], cwd=cwd)
+    if res.returncode == 0:
+        return True, res.stdout.strip()
+    return False, res.stderr.strip() or res.stdout.strip()
+
+
+def get_remotes(cwd: Optional[Path | str] = None) -> List[str]:
+    if not is_git_repository(cwd):
+        raise NotAGitRepositoryError("Not a Git repository.")
+
+    res = _run_git_command(["remote"], cwd=cwd)
+    if res.returncode != 0:
+        return []
+    output = res.stdout.strip()
+    if not output:
+        return []
+    return [line.strip() for line in output.splitlines() if line.strip()]
+
+
+def get_default_remote(cwd: Optional[Path | str] = None) -> Optional[str]:
+    remotes = get_remotes(cwd=cwd)
+    if "origin" in remotes:
+        return "origin"
+    return None
+
+
+def get_current_branch(cwd: Optional[Path | str] = None) -> Optional[str]:
+    if not is_git_repository(cwd):
+        raise NotAGitRepositoryError("Not a Git repository.")
+
+    res = _run_git_command(["branch", "--show-current"], cwd=cwd)
+    if res.returncode == 0 and res.stdout.strip():
+        return res.stdout.strip()
+
+    res_head = _run_git_command(["rev-parse", "--abbrev-ref", "HEAD"], cwd=cwd)
+    if res_head.returncode == 0:
+        out = res_head.stdout.strip()
+        if out and out != "HEAD":
+            return out
+
+    res_sha = _run_git_command(["rev-parse", "--short", "HEAD"], cwd=cwd)
+    if res_sha.returncode == 0 and res_sha.stdout.strip():
+        return f"HEAD (detached at {res_sha.stdout.strip()})"
+
+    return "HEAD (detached)"
+
+
+def push_commit(remote: str, branch: str, cwd: Optional[Path | str] = None) -> Tuple[bool, str]:
+    if not is_git_repository(cwd):
+        raise NotAGitRepositoryError("Not a Git repository.")
+
+    res = _run_git_command(["push", remote, branch], cwd=cwd)
+    if res.returncode == 0:
+        return True, res.stdout.strip() or f"Pushed to {remote}/{branch}"
+
+    err = res.stderr.strip() or res.stdout.strip()
+    err_lower = err.lower()
+
+    if "rejected" in err_lower and ("fetch first" in err_lower or "behind" in err_lower or "non-fast-forward" in err_lower):
+        clean_err = "The remote rejected the push because the branch is behind the remote."
+    elif "permission denied" in err_lower or "authentication failed" in err_lower or "invalid username or password" in err_lower or "403" in err_lower or "401" in err_lower:
+        clean_err = "Authentication failed for the remote repository."
+    elif "could not resolve host" in err_lower or "connection refused" in err_lower or "fatal: unable to access" in err_lower:
+        clean_err = "Could not connect to the remote repository. Please check your network connection."
+    elif "src refspec" in err_lower or "does not match any" in err_lower:
+        clean_err = f"Branch '{branch}' does not exist locally."
+    elif "no upstream" in err_lower or "set-upstream" in err_lower:
+        clean_err = f"No upstream branch configured for '{branch}'."
+    else:
+        first_line = err.splitlines()[0] if err.splitlines() else "Git push failed."
+        clean_err = first_line
+
+    return False, clean_err
+
+
+def get_commit_context(cwd: Optional[Path | str] = None, recent_commit_count: int = 5) -> CommitContext:
+    if not is_git_repository(cwd):
+        raise NotAGitRepositoryError("Not a Git repository.")
+
+    repo_name = get_repository_name(cwd=cwd)
+    branch = get_current_branch(cwd=cwd) or "HEAD (detached)"
+    changed_files = get_staged_changed_files(cwd=cwd)
+    diff_stat = get_diff_stat(cwd=cwd)
+    recent_commits = get_recent_commits(count=recent_commit_count, cwd=cwd)
+    staged_diff = get_staged_diff(cwd=cwd)
+
+    return CommitContext(
+        repository_name=repo_name,
+        current_branch=branch,
+        changed_files=changed_files,
+        recent_commits=recent_commits,
+        diff_stat=diff_stat,
+        staged_diff=staged_diff,
+    )

comit/prompts.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+import re
+from typing import List, Optional, Union
+
+from comit.commit.context import CommitContext, DiffStat
+
+MAX_DIFF_CHARS = 12000
+
+SYSTEM_PROMPT = """You are an expert Git commit assistant.
+Your task is to generate ONE concise, accurate, and high-quality Git commit message based on the provided staged diff and repository context.
+
+Requirements:
+1. The staged diff is the ultimate source of truth. Examine the staged diff to understand the exact changes made. Do NOT invent features or mention files/changes not present in the diff.
+2. Use the repository context (repository name, current branch, changed files, statistics) to understand the intent, scope, and domain of the modifications.
+3. Examine the recent commit history to infer and match the repository's existing style:
+   - If the repository uses Conventional Commits (e.g. feat:, fix:, refactor:, chore:, docs:, test:, style:), adhere to Conventional Commits.
+   - If the repository uses another consistent style (capitalization, prefix convention, imperative vs descriptive verbs, issue references), follow that style.
+   - If there is no commit history or style is mixed, use standard Conventional Commits.
+4. Do not let previous commits or branch names override what is actually present in the staged diff.
+5. Provide a specific, informative summary of the changes. Avoid vague subjects such as 'update stuff', 'fix bug', 'changes', 'misc updates', or 'refactoring'. Prefer specific descriptions directly supported by the staged diff.
+6. Keep the commit message concise (single-line subject, ideally under 72 characters).
+7. Do NOT wrap the message in quotation marks.
+8. Do NOT use markdown code blocks or backticks in the response.
+9. Do NOT include explanations, greetings, preamble, or commentary (e.g. do not write "Here is the commit message:").
+10. Return ONLY the commit message text.
+"""
+
+
+def truncate_diff(diff: str, max_chars: int = MAX_DIFF_CHARS) -> str:
+    if len(diff) <= max_chars:
+        return diff
+
+    truncated = diff[:max_chars]
+    last_newline = truncated.rfind("\n")
+    if last_newline > 0:
+        truncated = truncated[:last_newline]
+
+    return (
+        f"{truncated}\n\n"
+        "[... Staged diff truncated: changes were too large. Focus on the primary modifications shown above ...]"
+    )
+
+
+def build_commit_prompt(
+    context: Union[CommitContext, str],
+    recent_commits: Optional[List[str]] = None,
+    avoid_messages: Optional[List[str]] = None,
+) -> str:
+    if isinstance(context, str):
+        context_obj = CommitContext(
+            repository_name="",
+            current_branch="",
+            changed_files=[],
+            recent_commits=recent_commits or [],
+            diff_stat=DiffStat(),
+            staged_diff=context,
+        )
+    else:
+        context_obj = context
+        if recent_commits and not context_obj.recent_commits:
+            context_obj.recent_commits = recent_commits
+
+    safe_diff = truncate_diff(context_obj.staged_diff)
+    sections: List[str] = []
+
+    repo_meta: List[str] = []
+    if context_obj.repository_name:
+        repo_meta.append(f"Repository: {context_obj.repository_name}")
+    if context_obj.current_branch:
+        repo_meta.append(f"Branch: {context_obj.current_branch}")
+    if repo_meta:
+        sections.append("\n".join(repo_meta))
+
+    if context_obj.changed_files:
+        files_lines = [f.format_line() for f in context_obj.changed_files]
+        sections.append("Changed files:\n" + "\n".join(files_lines))
+
+    stat_summary = context_obj.diff_stat.format_summary()
+    if stat_summary and stat_summary != "0 files changed":
+        sections.append(f"Change statistics:\n  {stat_summary}")
+
+    if context_obj.recent_commits:
+        history_str = "\n".join(f"  {c}" for c in context_obj.recent_commits[:15])
+        sections.append(f"Recent commits:\n{history_str}")
+    else:
+        sections.append("Recent commits:\n  (No previous commits found; use Conventional Commits style)")
+
+    sections.append(f"Staged diff:\n```diff\n{safe_diff}\n```")
+
+    if avoid_messages:
+        avoid_str = "\n".join(f'- "{m}"' for m in avoid_messages if m and m.strip())
+        sections.append(
+            f"Previous suggestion(s) to avoid repeating:\n{avoid_str}\n\n"
+            "Please generate a DIFFERENT, alternative commit message that accurately describes the staged changes without repeating the previous suggestion(s)."
+        )
+    else:
+        sections.append("Generate ONE commit message for these changes:")
+
+    return "\n\n".join(sections)
+
+
+def sanitize_commit_message(raw_text: str) -> str:
+    if not raw_text:
+        return ""
+
+    text = raw_text.strip()
+
+    if text.startswith("```"):
+        text = re.sub(r"^```[a-zA-Z0-9_-]*\n?", "", text)
+        text = re.sub(r"\n?```$", "", text)
+        text = text.strip()
+
+    prefixes_to_strip = [
+        r"^commit\s*message\s*:\s*",
+        r"^suggested\s*commit\s*(message)?\s*:\s*",
+        r"^here\s+is\s+(the|a)\s+suggested\s+commit\s+message\s*:\s*",
+        r"^here\s+is\s+the\s+commit\s+message\s*:\s*",
+        r"^here\s+is\s+your\s+commit\s+message\s*:\s*",
+    ]
+    for prefix in prefixes_to_strip:
+        text = re.sub(prefix, "", text, flags=re.IGNORECASE).strip()
+
+    quote_pairs = [
+        ('"', '"'),
+        ("'", "'"),
+        ("`", "`"),
+        ("“", "”"),
+        ("‘", "’"),
+    ]
+    for start_q, end_q in quote_pairs:
+        if text.startswith(start_q) and text.endswith(end_q) and len(text) >= 2:
+            text = text[len(start_q):-len(end_q)].strip()
+
+    lines = [line.strip() for line in text.splitlines() if line.strip()]
+    if not lines:
+        return ""
+
+    if len(lines) > 1 and lines[0].lower().endswith(":") and len(lines[0].split()) < 8:
+        text = "\n\n".join(lines[1:])
+    else:
+        text = "\n\n".join(lines)
+
+    for start_q, end_q in quote_pairs:
+        if text.startswith(start_q) and text.endswith(end_q) and len(text) >= 2:
+            text = text[len(start_q):-len(end_q)].strip()
+
+    return text.strip()

comit/review/__init__.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from comit.review.base import BaseAnalyzer
+from comit.review.databases import DatabaseAnalyzer
+from comit.review.engine import ReviewEngine, review_changes
+from comit.review.generated_files import GeneratedFileAnalyzer
+from comit.review.git_files import GitFileAnalyzer
+from comit.review.large_files import DEFAULT_MAX_FILE_SIZE_BYTES, LargeFileAnalyzer
+from comit.review.models import ReviewFinding, ReviewResult, ReviewSeverity
+from comit.review.private_keys import PrivateKeyAnalyzer
+from comit.review.secrets import SecretAnalyzer
+from comit.review.sensitive_files import SensitiveFileAnalyzer
+
+__all__ = [
+    "ReviewSeverity",
+    "ReviewFinding",
+    "ReviewResult",
+    "BaseAnalyzer",
+    "SensitiveFileAnalyzer",
+    "SecretAnalyzer",
+    "PrivateKeyAnalyzer",
+    "DatabaseAnalyzer",
+    "LargeFileAnalyzer",
+    "GeneratedFileAnalyzer",
+    "GitFileAnalyzer",
+    "DEFAULT_MAX_FILE_SIZE_BYTES",
+    "ReviewEngine",
+    "review_changes",
+]

comit/review/base.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import List
+
+from comit.commit.context import CommitContext
+from comit.review.models import ReviewFinding
+
+
+class BaseAnalyzer(ABC):
+    @abstractmethod
+    def analyze(self, context: CommitContext) -> List[ReviewFinding]:
+        pass

comit/review/databases.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List
+
+from comit.commit.context import CommitContext
+from comit.review.base import BaseAnalyzer
+from comit.review.models import ReviewFinding, ReviewSeverity
+
+DATABASE_EXTENSIONS = {
+    ".db",
+    ".sqlite",
+    ".sqlite3",
+    ".rdb",
+    ".mdb",
+    ".accdb",
+}
+
+
+class DatabaseAnalyzer(BaseAnalyzer):
+    def analyze(self, context: CommitContext) -> List[ReviewFinding]:
+        findings: List[ReviewFinding] = []
+
+        for f in context.changed_files:
+            if f.status == "D":
+                continue
+
+            suffix = Path(f.path).suffix.lower()
+            if suffix in DATABASE_EXTENSIONS:
+                findings.append(
+                    ReviewFinding(
+                        severity=ReviewSeverity.WARNING,
+                        category="Database File",
+                        message="Database file staged",
+                        file_path=f.path,
+                        details="Binary database files should typically not be tracked in version control.",
+                    )
+                )
+
+        return findings

comit/review/engine.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from typing import List, Optional
+
+from comit.commit.context import CommitContext
+from comit.review.base import BaseAnalyzer
+from comit.review.databases import DatabaseAnalyzer
+from comit.review.generated_files import GeneratedFileAnalyzer
+from comit.review.git_files import GitFileAnalyzer
+from comit.review.large_files import LargeFileAnalyzer
+from comit.review.models import ReviewFinding, ReviewResult
+from comit.review.private_keys import PrivateKeyAnalyzer
+from comit.review.secrets import SecretAnalyzer
+from comit.review.sensitive_files import SensitiveFileAnalyzer
+
+
+class ReviewEngine:
+    def __init__(self, analyzers: Optional[List[BaseAnalyzer]] = None):
+        if analyzers is not None:
+            self.analyzers = analyzers
+        else:
+            self.analyzers = [
+                SensitiveFileAnalyzer(),
+                SecretAnalyzer(),
+                PrivateKeyAnalyzer(),
+                DatabaseAnalyzer(),
+                LargeFileAnalyzer(),
+                GeneratedFileAnalyzer(),
+                GitFileAnalyzer(),
+            ]
+
+    def run(self, context: CommitContext) -> ReviewResult:
+        all_findings: List[ReviewFinding] = []
+
+        for analyzer in self.analyzers:
+            findings = analyzer.analyze(context)
+            all_findings.extend(findings)
+
+        deduped = self._deduplicate_findings(all_findings)
+        deduped.sort(key=lambda f: (-f.severity.rank, f.file_path, f.category))
+
+        added_count = sum(1 for f in context.changed_files if f.status == "A")
+        modified_count = sum(1 for f in context.changed_files if f.status == "M")
+        deleted_count = sum(1 for f in context.changed_files if f.status == "D")
+        renamed_count = sum(1 for f in context.changed_files if f.status == "R")
+
+        return ReviewResult(
+            findings=deduped,
+            files_checked=len(context.changed_files),
+            diff_stat=context.diff_stat,
+            added_files_count=added_count,
+            modified_files_count=modified_count,
+            deleted_files_count=deleted_count,
+            renamed_files_count=renamed_count,
+        )
+
+    def _deduplicate_findings(self, findings: List[ReviewFinding]) -> List[ReviewFinding]:
+        deduped: List[ReviewFinding] = []
+        seen = set()
+
+        for f in findings:
+            key = (f.file_path, f.category, f.message, f.line_number)
+            if key in seen:
+                continue
+
+            is_duplicate = False
+            for idx, existing in enumerate(deduped):
+                if existing.file_path == f.file_path:
+                    if existing.category == "Private Key" and f.category == "Secret":
+                        if existing.line_number is None or f.line_number is None or existing.line_number == f.line_number:
+                            is_duplicate = True
+                            break
+                    elif f.category == "Private Key" and existing.category == "Secret":
+                        if existing.line_number is None or f.line_number is None or existing.line_number == f.line_number:
+                            deduped[idx] = f
+                            is_duplicate = True
+                            break
+                    elif existing.category == f.category and existing.message == f.message and existing.details == f.details:
+                        is_duplicate = True
+                        break
+
+            if not is_duplicate:
+                seen.add(key)
+                deduped.append(f)
+
+        return deduped
+
+
+def review_changes(context: CommitContext, engine: Optional[ReviewEngine] = None) -> ReviewResult:
+    if engine is None:
+        engine = ReviewEngine()
+    return engine.run(context)

comit/review/generated_files.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List
+
+from comit.commit.context import CommitContext
+from comit.review.base import BaseAnalyzer
+from comit.review.models import ReviewFinding, ReviewSeverity
+
+GENERATED_DIR_NAMES = {
+    "__pycache__",
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    "htmlcov",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".ruff_cache",
+    ".tox",
+}
+
+GENERATED_EXTENSIONS = {
+    ".pyc",
+    ".pyo",
+    ".pyd",
+}
+
+GENERATED_FILE_NAMES = {
+    ".coverage",
+}
+
+
+class GeneratedFileAnalyzer(BaseAnalyzer):
+    def analyze(self, context: CommitContext) -> List[ReviewFinding]:
+        findings: List[ReviewFinding] = []
+
+        for f in context.changed_files:
+            if f.status == "D":
+                continue
+
+            path_obj = Path(f.path)
+            parts = [p.lower() for p in path_obj.parts]
+            name = path_obj.name.lower()
+            suffix = path_obj.suffix.lower()
+
+            is_generated = False
+            matched_reason = ""
+
+            for part in parts[:-1]:
+                if part in GENERATED_DIR_NAMES:
+                    is_generated = True
+                    matched_reason = f"Located inside '{part}' directory"
+                    break
+
+            if not is_generated:
+                if name in GENERATED_FILE_NAMES:
+                    is_generated = True
+                    matched_reason = f"Artifact '{name}'"
+                elif suffix in GENERATED_EXTENSIONS:
+                    is_generated = True
+                    matched_reason = f"Compiled artifact ('{suffix}')"
+
+            if is_generated:
+                findings.append(
+                    ReviewFinding(
+                        severity=ReviewSeverity.INFO,
+                        category="Generated Artifact",
+                        message="Generated build or cache artifact staged",
+                        file_path=f.path,
+                        details=f"{matched_reason}. Consider adding it to .gitignore.",
+                    )
+                )
+
+        return findings