git-security-tool 0.1.0__py3-none-any.whl

git_security/scanners/ruff.py

@@ -0,0 +1,103 @@
+"""Ruff wrapper: staged Python files -> list[Finding].
+
+Knows how to talk to Ruff and how to map Ruff's JSON to the normalized
+``Finding`` model. Knows nothing about Git internals, policy, or reporting.
+
+Approach A (milestone 3): scans the files as they exist in the working tree,
+not the exact staged blobs. Editing a file after ``git add`` means Ruff sees
+the newer version. Precise staged-content scanning is a later milestone.
+"""
+
+import json
+from pathlib import Path
+
+from git_security.models.finding import Finding, Severity
+from git_security.scanners.base import run_tool, to_repo_relative
+
+_NOT_FOUND_MSG = (
+    "[git-security-tool] ruff not found on PATH - skipping "
+    "(activate your venv / pip install ruff)"
+)
+
+
+def run_ruff(files: list[str], repo_root: Path) -> list[Finding]:
+    """Lint the Python files in *files* and return normalized findings."""
+    python_files = [f for f in files if f.endswith(".py")]
+    if not python_files:
+        return []
+
+    proc = run_tool(["ruff", "check", "--output-format=json", "--", *python_files])
+    if proc is None:
+        print(_NOT_FOUND_MSG)
+        return []
+
+    # Ruff exit codes: 0 = clean, 1 = issues found, 2 = execution error.
+    if proc.returncode == 2:
+        raise RuntimeError(f"ruff failed: {proc.stderr.strip()}")
+
+    if not proc.stdout.strip():
+        return []
+
+    return [_to_finding(item, repo_root) for item in json.loads(proc.stdout)]
+
+
+def _to_finding(item: dict, repo_root: Path) -> Finding:
+    location = item.get("location") or {}
+    return Finding(
+        tool="ruff",
+        rule=item.get("code") or "",
+        severity=Severity.LOW,  # code quality never blocks by default
+        file=to_repo_relative(item.get("filename") or "", repo_root),
+        line=location.get("row") or 0,
+        message=item.get("message") or "",
+    )
+
+
+def run_ruff_format(files: list[str], repo_root: Path) -> list[Finding]:
+    """Report Python files that are not formatted (``ruff format --check``)."""
+    python_files = [f for f in files if f.endswith(".py")]
+    if not python_files:
+        return []
+
+    proc = run_tool(["ruff", "format", "--check", "--", *python_files])
+    if proc is None:
+        return []  # run_ruff already printed the "not found" message
+
+    # 0 = all formatted, 1 = some would be reformatted, >1 = execution error.
+    if proc.returncode == 0:
+        return []
+    if proc.returncode not in (0, 1):
+        raise RuntimeError(f"ruff format failed: {proc.stderr.strip()}")
+
+    findings: list[Finding] = []
+    seen: set[str] = set()
+    for line in f"{proc.stdout}\n{proc.stderr}".splitlines():
+        path = _parse_unformatted_path(line)
+        if path and path not in seen:
+            seen.add(path)
+            findings.append(
+                Finding(
+                    tool="ruff",
+                    rule="format",
+                    severity=Severity.LOW,
+                    file=to_repo_relative(path, repo_root),
+                    line=0,
+                    message="file is not formatted (run `ruff format`)",
+                )
+            )
+    return findings
+
+
+def _parse_unformatted_path(line: str) -> str | None:
+    """Pull the file path out of a `ruff format --check` output line."""
+    line = line.strip()
+    if line.startswith("--> "):  # newer ruff: " --> path:line:col"
+        loc = line[4:]
+        head, _, tail = loc.rpartition(":")
+        base, _, mid = head.rpartition(":")
+        if tail.isdigit() and mid.isdigit() and base:
+            return base
+        return loc
+    if line.startswith("Would reformat: "):  # older ruff
+        return line[len("Would reformat: ") :]
+    return None

git_security/scanners/semgrep.py

@@ -0,0 +1,81 @@
+"""Semgrep wrapper: staged files -> list[Finding].
+
+Runs Semgrep with our local rule set and maps Semgrep's JSON results to the
+normalized ``Finding`` model.
+
+Rule-source decision (milestone 6): we use only the local ``rules/semgrep/``
+directory - fully offline and deterministic, no code or metadata leaves the
+machine. Registry rule packs (``p/python``, ``p/security-audit``) can be
+added as an opt-in config option later.
+"""
+
+import json
+from pathlib import Path
+
+from git_security.models.finding import Finding, Severity
+from git_security.scanners.base import run_tool, to_repo_relative
+
+_NOT_FOUND_MSG = (
+    "[git-security-tool] semgrep not found on PATH - skipping (pip install semgrep)"
+)
+
+# Semgrep severities -> our severity scale.
+_SEVERITY_MAP = {
+    "ERROR": Severity.HIGH,
+    "WARNING": Severity.MEDIUM,
+    "INFO": Severity.LOW,
+}
+
+
+def run_semgrep(files: list[str], repo_root: Path, rules_dir: Path) -> list[Finding]:
+    """Scan *files* with the rules in *rules_dir* and return normalized findings."""
+    if not files:
+        return []
+    if not rules_dir.exists():
+        print(f"[git-security-tool] semgrep rules not found at {rules_dir} - skipping")
+        return []
+
+    proc = run_tool(
+        [
+            "semgrep",
+            "--config",
+            str(rules_dir),
+            "--json",
+            "--quiet",
+            "--metrics=off",
+            "--disable-version-check",
+            "--",
+            *files,
+        ]
+    )
+    if proc is None:
+        print(_NOT_FOUND_MSG)
+        return []
+
+    # Semgrep exit codes: 0 = no findings, 1 = findings found, >=2 = error.
+    if proc.returncode not in (0, 1):
+        detail = proc.stderr.strip() or proc.stdout.strip()
+        raise RuntimeError(f"semgrep failed: {detail}")
+
+    if not proc.stdout.strip():
+        return []
+
+    data = json.loads(proc.stdout)
+    return [_to_finding(r, repo_root) for r in data.get("results", [])]
+
+
+def _to_finding(result: dict, repo_root: Path) -> Finding:
+    extra = result.get("extra") or {}
+    start = result.get("start") or {}
+    # Semgrep prefixes check_id with the rule file's path
+    # (e.g. "src.git_security.rules.semgrep.python-dangerous-eval").
+    # Keep only the rule's own id.
+    check_id = result.get("check_id") or ""
+    return Finding(
+        tool="semgrep",
+        rule=check_id.rsplit(".", 1)[-1],
+        severity=_SEVERITY_MAP.get(extra.get("severity", ""), Severity.MEDIUM),
+        file=to_repo_relative(result.get("path") or "", repo_root),
+        line=start.get("line") or 0,
+        message=(extra.get("message") or "").strip(),
+    )

git_security/suggestions/llm.py

@@ -0,0 +1,67 @@
+"""Optional AI remediation suggestions - advisory, never changes the block.
+
+Runs only when all of these hold:
+
+* ``[ai] enabled = true`` in ``.git-security-tool.toml``
+* the configured provider's API key is set (``ANTHROPIC_API_KEY`` /
+  ``GEMINI_API_KEY``)
+* for the anthropic provider, the ``anthropic`` package is installed
+
+It never modifies files - it prints suggestions for the developer - and it
+always announces before sending code off the machine. Secret-bearing files
+are filtered out before this module is reached (see ``scan.py``).
+"""
+
+from git_security.config.loader import AIConfig
+from git_security.models.finding import Finding
+from git_security.suggestions.providers import PROVIDERS
+
+_PREFIX = "[git-security-tool]"
+
+_SYSTEM = (
+    "You are a security code-review assistant. You are given one static-analysis "
+    "finding and the surrounding code. Reply with exactly two parts: "
+    "(1) one sentence naming the risk, then "
+    "(2) a minimal safe rewrite of only the affected lines, in a code block. "
+    "No preamble, no extra commentary."
+)
+
+
+def suggestions_available(provider_name: str) -> bool:
+    provider = PROVIDERS.get(provider_name)
+    return provider is not None and provider.available()
+
+
+def build_prompt(finding: Finding, snippet: str) -> str:
+    return (
+        f"Finding: {finding.tool}:{finding.rule} [{finding.severity.name}]\n"
+        f"Location: {finding.file}:{finding.line}\n"
+        f"Message: {finding.message}\n\n"
+        f"Code:\n{snippet}"
+    )
+
+
+def explain(items: list[tuple[Finding, str]], config: AIConfig) -> None:
+    """Print a suggestion for each (finding, code snippet) pair."""
+    provider = PROVIDERS[config.provider]
+    model = config.model or provider.default_model
+
+    print(
+        f"{_PREFIX} sending {len(items)} finding(s) and code context to "
+        f"{provider.name} ({model}) for remediation suggestions..."
+    )
+
+    for finding, snippet in items:
+        try:
+            text = provider.complete(_SYSTEM, build_prompt(finding, snippet), model)
+        except RuntimeError as exc:
+            print(f"{_PREFIX} suggestion failed for {finding.file}: {exc}")
+            continue
+
+        print(
+            f"\n{_PREFIX} suggestion for {finding.file}:{finding.line} "
+            f"({finding.tool}:{finding.rule}):"
+        )
+        for line in text.strip().splitlines():
+            print(f"    {line}")
+    print()

git_security/suggestions/providers.py

@@ -0,0 +1,110 @@
+"""LLM providers for remediation suggestions.
+
+Each provider exposes the same tiny surface:
+
+* ``name``            - identifier used in ``[ai] provider`` and in messages
+* ``default_model``   - used when ``[ai] model`` is left blank
+* ``env_var``         - the API-key environment variable
+* ``available()``     - key present (and any SDK importable)
+* ``complete(system, user, model) -> str`` - one call, text back,
+  ``RuntimeError`` on any failure
+
+This layer is advisory only. The deterministic scanners decide whether a
+commit is blocked; providers just explain findings.
+"""
+
+import json
+import os
+import urllib.error
+import urllib.request
+
+_TIMEOUT = 30
+_MAX_OUTPUT_TOKENS = 2048
+
+
+class AnthropicProvider:
+    name = "anthropic"
+    default_model = "claude-opus-5"
+    env_var = "ANTHROPIC_API_KEY"
+
+    def available(self) -> bool:
+        if not os.environ.get(self.env_var):
+            return False
+        try:
+            import anthropic  # noqa: F401
+        except ImportError:
+            return False
+        return True
+
+    def complete(self, system: str, user: str, model: str) -> str:
+        import anthropic
+
+        try:
+            client = anthropic.Anthropic()
+            response = client.messages.create(
+                model=model or self.default_model,
+                max_tokens=_MAX_OUTPUT_TOKENS,
+                system=system,
+                messages=[{"role": "user", "content": user}],
+            )
+        except anthropic.AnthropicError as exc:
+            raise RuntimeError(f"Anthropic API error: {exc}") from exc
+        return "".join(b.text for b in response.content if b.type == "text")
+
+
+class GeminiProvider:
+    name = "gemini"
+    default_model = "gemini-2.5-flash"
+    env_var = "GEMINI_API_KEY"
+    _URL = (
+        "https://generativelanguage.googleapis.com/v1beta/models/"
+        "{model}:generateContent"
+    )
+
+    def available(self) -> bool:
+        return bool(os.environ.get(self.env_var))
+
+    def complete(self, system: str, user: str, model: str) -> str:
+        url = self._URL.format(model=model or self.default_model)
+        body = json.dumps(
+            {
+                "systemInstruction": {"parts": [{"text": system}]},
+                "contents": [{"parts": [{"text": user}]}],
+                "generationConfig": {"maxOutputTokens": _MAX_OUTPUT_TOKENS},
+            }
+        ).encode()
+        request = urllib.request.Request(  # noqa: S310 - hardcoded https host
+            url,
+            data=body,
+            headers={
+                "Content-Type": "application/json",
+                "x-goog-api-key": os.environ[self.env_var],
+            },
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(request, timeout=_TIMEOUT) as resp:  # noqa: S310
+                payload = json.load(resp)
+        except urllib.error.HTTPError as exc:
+            detail = exc.read().decode("utf-8", "replace")[:300]
+            raise RuntimeError(f"Gemini API error {exc.code}: {detail}") from exc
+        except (urllib.error.URLError, TimeoutError) as exc:
+            raise RuntimeError(f"Gemini request failed: {exc}") from exc
+
+        candidates = payload.get("candidates") or []
+        if not candidates:
+            reason = payload.get("promptFeedback", {}).get(
+                "blockReason", "no candidates returned"
+            )
+            raise RuntimeError(f"Gemini returned nothing ({reason})")
+        parts = candidates[0].get("content", {}).get("parts") or []
+        text = "".join(p.get("text", "") for p in parts)
+        if not text:
+            raise RuntimeError(
+                "Gemini response had no text "
+                f"(finishReason={candidates[0].get('finishReason')})"
+            )
+        return text
+
+
+PROVIDERS = {p.name: p for p in (AnthropicProvider(), GeminiProvider())}

git_security_tool-0.1.0.dist-info/METADATA

@@ -0,0 +1,149 @@
+Metadata-Version: 2.5
+Name: git-security-tool
+Version: 0.1.0
+Summary: Local Git security and code-quality gate that runs on pre-commit.
+Project-URL: Homepage, https://github.com/MustafaBasit521/commit-guard
+Project-URL: Issues, https://github.com/MustafaBasit521/commit-guard/issues
+Author: Muhammad Mustafa Basit
+License-Expression: MIT
+License-File: LICENSE
+Keywords: git,gitleaks,pre-commit,sast,secrets,security,semgrep
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.11
+Provides-Extra: ai
+Requires-Dist: anthropic; extra == 'ai'
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Provides-Extra: scanners
+Requires-Dist: ruff; extra == 'scanners'
+Requires-Dist: semgrep; extra == 'scanners'
+Description-Content-Type: text/markdown
+
+# git-security-tool
+
+[![CI](https://github.com/MustafaBasit521/commit-guard/actions/workflows/ci.yml/badge.svg)](https://github.com/MustafaBasit521/commit-guard/actions/workflows/ci.yml)
+
+A local Git **pre-commit gate** for Linux. It scans your *staged* changes and
+blocks the commit when it finds something serious — secrets, dangerous code
+patterns — while surfacing quality and formatting issues as warnings.
+
+It is an **orchestration layer**, not a new scanner: it runs
+[Gitleaks](https://github.com/gitleaks/gitleaks),
+[Semgrep](https://semgrep.dev/), and [Ruff](https://docs.astral.sh/ruff/),
+normalizes their output, applies your policy, and decides pass/block.
+
+```
+git commit
+   └─► .git/hooks/pre-commit
+        └─► git-security-tool scan
+             ├─ gitleaks   → secrets            (CRITICAL → blocks)
+             ├─ semgrep    → security patterns  (HIGH → blocks)
+             ├─ ruff check → lint               (LOW → warns)
+             └─ ruff format --check → format    (LOW → warns)
+                  └─► PASS (exit 0) / BLOCK (exit 1)
+```
+
+## Install
+
+```bash
+pip install "git-security-tool[scanners]"     # tool + ruff + semgrep
+cd your-repo
+git-security-tool install                     # writes .git/hooks/pre-commit
+```
+
+Latest unreleased version, straight from the repo:
+
+```bash
+pip install "git-security-tool[scanners] @ git+https://github.com/MustafaBasit521/commit-guard.git"
+```
+
+Gitleaks is a Go binary — install it separately if you want secret detection
+(the scan skips any tool that isn't on `PATH`).
+
+Commands: `scan [--all] [--format sarif]`, `baseline`, `install [--force]`,
+`uninstall`, `check`, `version`.
+
+- `scan` — staged changes (pre-commit)
+- `scan --all` — every tracked file (CI / audit); `--format sarif` emits SARIF
+  on stdout for GitHub code scanning
+- `baseline` — records current findings to `.git-security-tool-baseline.json`
+  so a repo can adopt the tool without fixing everything first; new issues
+  still block
+
+## What it checks
+
+| category | tool | severity | blocks by default |
+|---|---|---|---|
+| Secrets / credentials | Gitleaks (staged diff) | CRITICAL | yes |
+| Insecure code patterns (17 rules) | Semgrep + bundled rules | HIGH / MEDIUM | HIGH yes |
+| Lint (unused imports, undefined names, …) | `ruff check` | LOW | no |
+| Formatting | `ruff format --check` | LOW | no |
+
+The bundled Semgrep rules (`src/git_security/rules/semgrep/`) cover code/command
+injection (`eval`, `exec`, `os.system`, `shell=True`), unsafe deserialization
+(`pickle`, `yaml.load`, insecure XML), weak crypto & disabled TLS verification,
+web footguns (Flask `debug=True`, Jinja autoescape off, `mark_safe`), and
+filesystem/network hygiene (`extractall`, `mktemp`, `requests` without timeout).
+
+Semgrep/Ruff analysis is **Python only**; Gitleaks is language-agnostic.
+Scanners see the exact **staged** content, not your working tree.
+
+## Configuration — `.git-security-tool.toml` (optional, repo root)
+
+```toml
+[policy]
+block_threshold = "HIGH"          # INFO | LOW | MEDIUM | HIGH | CRITICAL
+
+[scanners]
+gitleaks = false                  # disable a scanner
+
+[ignore]
+paths = ["tests/fixtures/", "*.generated.py"]
+
+[ai]
+enabled = false                   # optional LLM remediation suggestions
+provider = "gemini"               # "anthropic" | "gemini"
+model = ""                        # blank = provider default
+max_findings = 3
+```
+
+**AI suggestions** are off by default and advisory only — they never affect
+the pass/block decision or modify files, they announce before sending code
+to the API, and secret-bearing files are never sent.
+
+| provider | key env var | extra install |
+|---|---|---|
+| `gemini` | `GEMINI_API_KEY` | none (stdlib HTTP) |
+| `anthropic` | `ANTHROPIC_API_KEY` | `pip install ".[ai]"` |
+
+## Overrides
+
+- `GIT_SECURITY_NO_BLOCK=1 git commit …` — run the scan, report, never block.
+- `git commit --no-verify` — skip the hook entirely (Git built-in).
+
+## Development
+
+```bash
+pip install -e ".[scanners,dev]"
+pytest
+ruff check src tests && ruff format --check src tests
+```
+
+## Scope / non-goals
+
+No dependency-CVE scanning, no license checks, no SBOM, no IaC/container
+scanning, no non-Python static analysis. The bundled Semgrep ruleset is
+curated and intentionally small — not a replacement for a full SAST platform
+or the Semgrep registry.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

git_security_tool-0.1.0.dist-info/RECORD

@@ -0,0 +1,41 @@
+git_security/__init__.py,sha256=9Ib4IpixasuGfmRXPglAU8a7bztRuL2xldeiBi0beYY,92
+git_security/__main__.py,sha256=67q1VsxrDi8_JYkHoBXVJ2NXsDEoiu58Qb4LLU8zhys,100
+git_security/baseline.py,sha256=WwmkzXrq8wUtBHW0h502Z16kPDhK2Nh-9M8DQlD0h0Y,2216
+git_security/cli.py,sha256=SyV3VTK6nUxxCRl4fDmGCyIWSumkZR4ny5K_PhFI7QI,2745
+git_security/ignore.py,sha256=0ORE9hsX3aZTxGSRrXE7Kp2tadFa9mU7-Aawbi2FDFc,882
+git_security/scan.py,sha256=MUk08tkuKYKuAVEDycn-Fe40CxUNIpHUywx16WK7p6o,8870
+git_security/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+git_security/config/loader.py,sha256=mDJOajILb5jS8HA0YeCDu4jEYWMcXfKr5gEOEnCoMc4,4152
+git_security/git/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+git_security/git/diff.py,sha256=filp69ZDfaLJzqAuj-_Tot4YSKs9Z3_XkbG-8fMzK-o,1826
+git_security/git/hooks.py,sha256=3ELh7MU5Zp9fQ96wmXEHn7YfNYA3Oh7-FPNPFq7DM0k,808
+git_security/git/repository.py,sha256=FofI9V0T0MV4z9YxnYSQVlGt5f-FIaqnER4dO-vormg,1152
+git_security/installer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+git_security/installer/dependencies.py,sha256=XJXsAAx3QYY0yZxSPV9kVT2k9vSl7wkVSiLa2UgHwug,453
+git_security/installer/git_hook.py,sha256=LJlG10PW0lmQO4SDESgpnIULF-Z5jGVH2XNq703jNoo,3493
+git_security/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+git_security/models/finding.py,sha256=K05V8_0xIP22RsIvnMnQA8vQxExZK3grJ1VVYQBvP9A,935
+git_security/policy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+git_security/policy/engine.py,sha256=SReP9g9BaDB3tCue3mhLhjolHVX4pvVEU2eNJchx05g,1278
+git_security/reporter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+git_security/reporter/sarif.py,sha256=vAq4Z-MFwzm1VgHma3_zotvm04LRIEARzX7YbNEgE2U,2088
+git_security/reporter/terminal.py,sha256=5tyczZHGDEsM3uKVB_YRwvprmpsd0kirOY2WWSLl8is,1545
+git_security/rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+git_security/rules/semgrep/crypto_tls.yml,sha256=q8CzV3TdVnq1vgOWn1bdmXftfcw-yW571KQookimN_c,1408
+git_security/rules/semgrep/deserialization.yml,sha256=ux1ZmYP1dbKLw_uddAyYDx90jLmNOLbd6ARohUuNi20,1450
+git_security/rules/semgrep/filesystem_net.yml,sha256=5-bKkebIABTjEtyeCIHC9Md-tVefhnREw4DDcoGuSbI,1348
+git_security/rules/semgrep/injection.yml,sha256=I5e0fzltTbnxQBhhqCYpC64daE-85cr1hmRrzjAnrik,1393
+git_security/rules/semgrep/web.yml,sha256=v47KwR3JCUyD0Jpy6bpVkZY8VOA7pVPyTa4RutVZY5g,1194
+git_security/scanners/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+git_security/scanners/base.py,sha256=DbJAd1eS7ruXReLezgmJ8zjSSTkSftUAFXWetVWlOWw,1119
+git_security/scanners/gitleaks.py,sha256=3tByuHxBVLtlj2ceikYe9Q2TcYffb46RffSQGRilt78,1869
+git_security/scanners/ruff.py,sha256=SDMeTevpZ5I50PTkaeDpVFbuwDXJhpuHKtYbm1HUnaQ,3652
+git_security/scanners/semgrep.py,sha256=zV4-HeVArjx3LgS12SMpEk4pqlHCXF-_yxNjWu9kpiw,2603
+git_security/suggestions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+git_security/suggestions/llm.py,sha256=0-KOjgHFcfgGENK--8JQBRk7ACiY-IZVu9xM-k1am_E,2409
+git_security/suggestions/providers.py,sha256=ku7G6Iv0fV2ScsN1OC4kNSpnvu77OsgPAZ_gQeQVSyk,3830
+git_security_tool-0.1.0.dist-info/METADATA,sha256=vneuYGLJ3vXQCcMrLF2WRySJZw35cSp0CZkZQDgLbRI,5569
+git_security_tool-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+git_security_tool-0.1.0.dist-info/entry_points.txt,sha256=NXfJ9zp9fFPnybQF1HcwP8msR7qXy6GbAeqAS6eBmbQ,60
+git_security_tool-0.1.0.dist-info/licenses/LICENSE,sha256=ymE5r69euauSBB_4QN1rLQuZ5yEOveh0Ctx3z5SCzw4,1079
+git_security_tool-0.1.0.dist-info/RECORD,,

git_security_tool-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

git_security_tool-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+git-security-tool = git_security.cli:main

git_security_tool-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Muhammad Mustafa Basit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.