rafter-cli 0.8.7__tar.gz → 0.8.9__tar.gz

{rafter_cli-0.8.7 → rafter_cli-0.8.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rafter-cli
-Version: 0.8.7
+Version: 0.8.9
 Summary: Rafter CLI — the default security agent for AI workflows. Free for individuals and open source.
 License: MIT
 Author: Rafter Team

{rafter_cli-0.8.7 → rafter_cli-0.8.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rafter-cli"
-version = "0.8.7"
+version = "0.8.9"
 description = "Rafter CLI — the default security agent for AI workflows. Free for individuals and open source."
 authors = ["Rafter Team <hello@rafter.so>"]
 license = "MIT"

{rafter_cli-0.8.7 → rafter_cli-0.8.9}/rafter_cli/commands/agent.py

@@ -25,7 +25,12 @@ from rich import print as rprint
 from .. import __version__
 from ..core.audit_logger import AuditLogger
 from ..core.command_interceptor import CommandInterceptor
-from ..core.config_manager import ConfigManager
+from ..core.config_manager import (
+    ConfigManager,
+    is_secret_config_key,
+    mask_secret_value,
+    redact_config_secrets,
+)
 from ..core.pattern_engine import PatternEngine
 from ..scanners.betterleaks import BetterleaksScanner
 from ..scanners.regex_scanner import RegexScanner, ScanResult
@@ -47,7 +52,7 @@ def config_show():
     from dataclasses import asdict
 
     manager = ConfigManager()
-    print(json.dumps(asdict(manager.load()), indent=2))
+    print(json.dumps(redact_config_secrets(asdict(manager.load())), indent=2))
 
 
 @config_app.command("get")
@@ -58,8 +63,11 @@ def config_get(key: str = typer.Argument(..., help="Config key (e.g. agent.risk_
     if value is None:
         print(f"Key not found: {key}", file=sys.stderr)
         raise typer.Exit(code=1)
+    leaf = key.split(".")[-1]
     if isinstance(value, dict):
-        print(json.dumps(value, indent=2))
+        print(json.dumps(redact_config_secrets(value), indent=2))
+    elif is_secret_config_key(leaf) and isinstance(value, str):
+        print(mask_secret_value(value))
     else:
         print(value)
 
@@ -76,7 +84,13 @@ def config_set(
     except (json.JSONDecodeError, ValueError):
         parsed = value
     manager.set(key, parsed)
-    rprint(fmt.success(f"Set {key} = {json.dumps(parsed)}"))
+    leaf = key.split(".")[-1]
+    echo = (
+        json.dumps(mask_secret_value(parsed))
+        if is_secret_config_key(leaf) and isinstance(parsed, str)
+        else json.dumps(parsed)
+    )
+    rprint(fmt.success(f"Set {key} = {echo}"))
 
 
 agent_app.add_typer(config_app)
@@ -251,6 +265,7 @@ def _print_dry_run_plan(
     want_aider: bool,
     want_hermes: bool,
     want_betterleaks: bool,
+    want_skill_scanner: bool,
     risk_level: str,
 ) -> None:
     """Print every file path the install would touch — without writing anything (rf-hrtd).
@@ -295,6 +310,11 @@ def _print_dry_run_plan(
         print("Betterleaks (--with-betterleaks / --all):")
         D(home / ".rafter" / "bin" / "betterleaks", "binary, ~12MB from GitHub releases")
 
+    if want_skill_scanner:
+        print()
+        print("skill-scanner deep engine (--with-skill-scanner):")
+        D(Path("skill-scanner"), "heavy PyPI package, isolated install via uv tool / pip --user")
+
     if want_claude_code:
         print()
         print("Claude Code (--with-claude-code):")
@@ -1036,6 +1056,7 @@ def _install_hermes_mcp(root: Path) -> bool:
 def init(
     risk_level: str = typer.Option("moderate", "--risk-level", help="minimal, moderate, or aggressive"),
     with_betterleaks: bool = typer.Option(False, "--with-betterleaks", help="Download and install Betterleaks binary"),
+    with_skill_scanner: bool = typer.Option(False, "--with-skill-scanner", help="Install the optional skill-scanner deep engine (heavy; audit-skill --deep)"),
     with_openclaw: bool = typer.Option(False, "--with-openclaw", help="Install OpenClaw integration"),
     with_claude_code: bool = typer.Option(False, "--with-claude-code", help="Install Claude Code integration"),
     with_codex: bool = typer.Option(False, "--with-codex", help="Install Codex CLI integration"),
@@ -1109,6 +1130,8 @@ def init(
     # established. Excluded from --all in --local for the same reason (sable-gyw).
     want_hermes = with_hermes or (all_integrations and not local)
     want_betterleaks = with_betterleaks or (all_integrations and not local)
+    # skill-scanner is heavy and opt-in only — deliberately NOT folded into --all.
+    want_skill_scanner = with_skill_scanner
 
     # Show detected environments
     detected = []
@@ -1175,6 +1198,7 @@ def init(
             want_aider=want_aider and (has_aider or local),
             want_hermes=want_hermes and has_hermes,
             want_betterleaks=want_betterleaks,
+            want_skill_scanner=want_skill_scanner,
             risk_level=risk_level,
         )
         return
@@ -1229,6 +1253,29 @@ def init(
                     "and ensure it is on PATH, then re-run 'rafter agent init'."
                 ))
 
+    if want_skill_scanner:
+        _ss_on_path = None if update else shutil.which("skill-scanner")
+        if _ss_on_path:
+            rprint(fmt.success(f"skill-scanner available on PATH ({_ss_on_path})"))
+        else:
+            from ..scanners.skill_scanner import SkillScannerInstaller
+
+            rprint(fmt.info(
+                "Installing optional skill-scanner deep engine (heavy "
+                "third-party package; isolated install)..."
+            ))
+            _result = SkillScannerInstaller().install(on_progress=typer.echo)
+            if _result.ok:
+                rprint(fmt.success(
+                    f"skill-scanner installed (via {_result.via}): {_result.message}"
+                ))
+            else:
+                rprint(fmt.warning(f"skill-scanner install failed: {_result.message}"))
+                rprint(fmt.info(
+                    "To fix: run 'rafter agent update-skill-scanner' or install "
+                    "manually with 'uv tool install cisco-ai-skill-scanner'."
+                ))
+
     # Install OpenClaw skill if opted in
     openclaw_ok = False
     if has_openclaw and want_openclaw:
@@ -1575,6 +1622,76 @@ def _scan_file(file_path: str, engine: str, custom_patterns=None) -> list[ScanRe
     return run_patterns()
 
 
+def _run_git_added_line_scan(
+    git_args: list[str],
+    git_cwd: str | None,
+    custom_patterns,
+    scan_cfg,
+    baseline_entries: list,
+    suppressions,
+    context_label: str,
+    empty_message: str,
+    *,
+    json_output: bool,
+    quiet: bool,
+    format: str,
+    not_repo_message: str = "Error: Not in a git repository or invalid ref",
+) -> None:
+    """Parse a unified diff for + lines and scan with the patterns engine."""
+    from ..utils.git_diff import parse_unified_diff_added_lines
+    from ..scanners.git_diff_scan import scan_added_diff_lines
+
+    try:
+        patch = subprocess.run(
+            ["git", *git_args],
+            capture_output=True,
+            text=True,
+            check=True,
+            cwd=git_cwd,
+        ).stdout
+    except subprocess.CalledProcessError:
+        print(not_repo_message, file=sys.stderr)
+        raise typer.Exit(code=2)
+
+    if not patch.strip():
+        if not quiet:
+            rprint(fmt.success(empty_message))
+        raise typer.Exit(code=0)
+
+    added = parse_unified_diff_added_lines(patch)
+    if not added:
+        if not quiet:
+            rprint(fmt.success(empty_message))
+        raise typer.Exit(code=0)
+
+    try:
+        repo_root = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            capture_output=True,
+            text=True,
+            check=True,
+            cwd=git_cwd,
+        ).stdout.strip()
+    except subprocess.CalledProcessError:
+        print(not_repo_message, file=sys.stderr)
+        raise typer.Exit(code=2)
+
+    file_count = len({line.file for line in added})
+    if not quiet:
+        print(
+            f"Scanning {len(added)} added line(s) in {file_count} file(s) ({context_label})...",
+            file=sys.stderr,
+        )
+
+    all_results = scan_added_diff_lines(added, repo_root, custom_patterns)
+    exclude = scan_cfg.exclude_paths if scan_cfg else None
+    all_results = _apply_exclude_paths(all_results, exclude, repo_root)
+    filtered = _apply_baseline(all_results, baseline_entries)
+    _output_scan_results(
+        filtered, json_output, quiet, context_label, format=format, suppressions=suppressions
+    )
+
+
 def _path_matches_exclude_pattern(rel_path: str, pattern: str) -> bool:
     """Mirror of Node ``pathMatchesExcludePattern`` (sable-yz0).
 
@@ -1938,64 +2055,42 @@ def scan(
 
     baseline_entries = _load_baseline_entries() if baseline else []
 
+    resolved_scan_path = os.path.abspath(path)
+    git_cwd = resolved_scan_path if os.path.isdir(resolved_scan_path) else None
+
     # --diff
     if diff:
-        try:
-            diff_output = subprocess.run(
-                ["git", "diff", "--name-only", "--diff-filter=ACM", diff],
-                capture_output=True, text=True, check=True,
-            ).stdout.strip()
-        except subprocess.CalledProcessError:
-            print("Error: Not in a git repository or invalid ref", file=sys.stderr)
-            raise typer.Exit(code=2)
-
-        if not diff_output:
-            if not quiet:
-                rprint(fmt.success(f"No files changed since {diff}"))
-            raise typer.Exit(code=0)
-
-        changed = [f.strip() for f in diff_output.split("\n") if f.strip()]
-        if not quiet:
-            print(f"Scanning {len(changed)} file(s) changed since {diff}...", file=sys.stderr)
-
-        eng = _select_engine(engine, quiet, auto_update_enabled)
-        all_results: list[ScanResult] = []
-        for f in changed:
-            resolved = os.path.abspath(f)
-            if os.path.isfile(resolved):
-                all_results.extend(_scan_file(resolved, eng, custom_patterns))
-        filtered = _apply_baseline(all_results, baseline_entries)
-        _output_scan_results(filtered, json_output, quiet, f"files changed since {diff}", format=format, suppressions=suppressions)
+        _run_git_added_line_scan(
+            ["diff", "-U0", "--no-color", "--diff-filter=ACM", diff],
+            git_cwd,
+            custom_patterns,
+            scan_cfg,
+            baseline_entries,
+            suppressions,
+            f"files changed since {diff}",
+            f"No files changed since {diff}",
+            json_output=json_output,
+            quiet=quiet,
+            format=format,
+        )
         return
 
     # --staged
     if staged:
-        try:
-            staged_output = subprocess.run(
-                ["git", "diff", "--cached", "--name-only", "--diff-filter=ACM"],
-                capture_output=True, text=True, check=True,
-            ).stdout.strip()
-        except subprocess.CalledProcessError:
-            print("Error: Not in a git repository", file=sys.stderr)
-            raise typer.Exit(code=2)
-
-        if not staged_output:
-            if not quiet:
-                rprint(fmt.success("No files staged for commit"))
-            raise typer.Exit(code=0)
-
-        staged_files = [f.strip() for f in staged_output.split("\n") if f.strip()]
-        if not quiet:
-            print(f"Scanning {len(staged_files)} staged file(s)...", file=sys.stderr)
-
-        eng = _select_engine(engine, quiet, auto_update_enabled)
-        all_results = []
-        for f in staged_files:
-            resolved = os.path.abspath(f)
-            if os.path.isfile(resolved):
-                all_results.extend(_scan_file(resolved, eng, custom_patterns))
-        filtered = _apply_baseline(all_results, baseline_entries)
-        _output_scan_results(filtered, json_output, quiet, "staged files", format=format, suppressions=suppressions)
+        _run_git_added_line_scan(
+            ["diff", "-U0", "--no-color", "--cached", "--diff-filter=ACM"],
+            git_cwd,
+            custom_patterns,
+            scan_cfg,
+            baseline_entries,
+            suppressions,
+            "staged files",
+            "No files staged for commit",
+            json_output=json_output,
+            quiet=quiet,
+            format=format,
+            not_repo_message="Error: Not in a git repository",
+        )
         return
 
     # Default: scan path
@@ -2232,17 +2327,26 @@ def exec_cmd(
         interceptor.log_evaluation(evaluation, "blocked")
         raise typer.Exit(code=1)
 
-    # Pre-exec scan for git commands
+    # Pre-exec scan for git commands (+ lines in staged diff only)
     if not skip_scan and command.strip().startswith(("git commit", "git push")):
         try:
-            staged = subprocess.run(
-                ["git", "diff", "--cached", "--name-only"],
-                capture_output=True, text=True,
-            ).stdout.strip().split("\n")
-            staged = [f for f in staged if f]
-            if staged:
-                scanner = RegexScanner()
-                results = scanner.scan_files(staged)
+            from ..utils.git_diff import parse_unified_diff_added_lines
+            from ..scanners.git_diff_scan import scan_added_diff_lines
+
+            patch = subprocess.run(
+                ["git", "diff", "-U0", "--no-color", "--cached", "--diff-filter=ACM"],
+                capture_output=True,
+                text=True,
+            ).stdout
+            if patch.strip():
+                repo_root = subprocess.run(
+                    ["git", "rev-parse", "--show-toplevel"],
+                    capture_output=True,
+                    text=True,
+                    check=True,
+                ).stdout.strip()
+                added = parse_unified_diff_added_lines(patch)
+                results = scan_added_diff_lines(added, repo_root)
                 total = sum(len(r.matches) for r in results)
                 if results:
                     rprint(f"\n{fmt.warning('Secrets detected in staged files!')}\n")
@@ -2997,11 +3101,50 @@ def _generate_manual_review_prompt(
 Provide a clear risk rating (LOW/MEDIUM/HIGH/CRITICAL) and actionable recommendations."""
 
 
+def _display_deep_scan(deep, skill_name: str) -> None:
+    """Render human-readable skill-scanner (deep engine) results."""
+    print("\n\U0001f50e Deep Scan Results (skill-scanner)")
+    print("═" * 60)
+    if not deep.available:
+        print("⚠️  skill-scanner not available")
+        return
+    if deep.error:
+        print(f"⚠️  Deep scan error: {deep.error}")
+        return
+    actionable = [f for f in deep.findings if f.severity in ("critical", "high", "medium")]
+    if not actionable:
+        print("✓ No critical/high/medium findings")
+    else:
+        print(f"⚠️  {len(actionable)} finding(s) (max severity: {deep.max_severity})")
+        for f in actionable[:10]:
+            loc = f" (line {f.line})" if f.line else ""
+            print(f"   • [{f.severity.upper()}] {f.category}: {f.title}{loc}")
+        if len(actionable) > 10:
+            print(f"   ... and {len(actionable) - 10} more")
+    if deep.analyzers_used:
+        print(f"   analyzers: {', '.join(deep.analyzers_used)} (offline only)")
+    print()
+
+
 @agent_app.command("audit-skill")
 def audit_skill(
     skill_path: str = typer.Argument(..., help="Path to skill file to audit"),
     skip_openclaw: bool = typer.Option(False, "--skip-openclaw", help="Skip OpenClaw integration, show manual review prompt"),
     json_output: bool = typer.Option(False, "--json", help="Output results as JSON"),
+    deep: bool = typer.Option(
+        False,
+        "--deep",
+        help=(
+            "Run the optional DEEP engine (Cisco AI Defense skill-scanner) in "
+            "addition to the quick scan. Offline analyzers only — no LLM/cloud/"
+            "network. Requires `cisco-ai-skill-scanner` to be installed."
+        ),
+    ),
+    engine: str = typer.Option(
+        None,
+        "--engine",
+        help="Deep engine selector. 'skill-scanner' is equivalent to --deep.",
+    ),
 ) -> None:
     """[deprecated] Security audit of a Claude Code skill file — use `rafter skill review` instead."""
     if not json_output:
@@ -3009,14 +3152,27 @@ def audit_skill(
             "[deprecated] `rafter agent audit-skill` is deprecated; use `rafter skill review <path-or-url>` instead.",
             file=sys.stderr,
         )
-    # Validate skill file exists
+    # Validate target exists. Accept either a skill *file* (.md) or a skill
+    # *directory*. The deep engine (--deep) is most thorough on a directory,
+    # where it can also see bundled scripts / .pyc; the quick scan reads the
+    # directory's SKILL.md (or the file itself).
     resolved = Path(skill_path).resolve()
     if not resolved.exists():
-        print(f"Error: Skill file not found: {skill_path}", file=sys.stderr)
+        print(f"Error: Skill path not found: {skill_path}", file=sys.stderr)
         raise typer.Exit(code=2)
 
-    skill_content = resolved.read_text(encoding="utf-8")
-    skill_name = resolved.name
+    if resolved.is_dir():
+        skill_md = resolved / "SKILL.md"
+        if skill_md.is_file():
+            skill_content = skill_md.read_text(encoding="utf-8")
+        else:
+            # No SKILL.md to quick-scan; the deep engine can still scan the
+            # directory's contents. Quick scan simply finds nothing.
+            skill_content = ""
+        skill_name = resolved.name
+    else:
+        skill_content = resolved.read_text(encoding="utf-8")
+        skill_name = resolved.name
 
     # Run deterministic analysis
     if not json_output:
@@ -3030,11 +3186,44 @@ def audit_skill(
     if not json_output:
         _display_quick_scan(quick_scan, skill_name)
 
+    # Optional DEEP engine (skill-scanner) — opt-in via --deep or
+    # --engine skill-scanner. Offline analyzers only; preserves our
+    # no-telemetry default (sable-7g7).
+    want_deep = deep or (engine == "skill-scanner")
+    if engine is not None and engine != "skill-scanner":
+        print(
+            f"Error: unknown --engine '{engine}' (supported: skill-scanner)",
+            file=sys.stderr,
+        )
+        raise typer.Exit(code=2)
+
+    deep_result = None
+    if want_deep:
+        from ..scanners.skill_scanner import SkillScanner
+
+        scanner = SkillScanner()
+        if not scanner.is_available():
+            # --deep requested but tool missing: clear hint, non-zero exit,
+            # don't crash.
+            from ..scanners.skill_scanner import INSTALL_HINT
+
+            print(INSTALL_HINT, file=sys.stderr)
+            raise typer.Exit(code=2)
+        deep_result = scanner.scan_path(str(resolved))
+        if deep_result.error:
+            print(f"Error: deep scan failed: {deep_result.error}", file=sys.stderr)
+            raise typer.Exit(code=2)
+        if not json_output:
+            _display_deep_scan(deep_result, skill_name)
+
     # Check OpenClaw availability
     skill_manager = SkillManager()
     openclaw_available = skill_manager.is_openclaw_installed()
     rafter_skill_installed = skill_manager.is_rafter_skill_installed()
 
+    quick_has_findings = quick_scan.secrets > 0 or len(quick_scan.high_risk_commands) > 0
+    deep_has_findings = deep_result.has_findings if deep_result else False
+
     if json_output:
         result = {
             "skill": skill_name,
@@ -3047,7 +3236,14 @@ def audit_skill(
             "openClawAvailable": openclaw_available,
             "rafterSkillInstalled": rafter_skill_installed,
         }
-        has_findings = quick_scan.secrets > 0 or len(quick_scan.high_risk_commands) > 0
+        if deep_result is not None:
+            result["deepScan"] = {
+                "engine": "skill-scanner",
+                "maxSeverity": deep_result.max_severity,
+                "analyzersUsed": deep_result.analyzers_used,
+                "findings": [f.to_dict() for f in deep_result.findings],
+            }
+        has_findings = quick_has_findings or deep_has_findings
         print(json.dumps(result, indent=2))
         raise typer.Exit(code=1 if has_findings else 0)
 
@@ -3084,7 +3280,7 @@ def audit_skill(
 
     print()
 
-    if quick_scan.secrets > 0 or len(quick_scan.high_risk_commands) > 0:
+    if quick_has_findings or deep_has_findings:
         raise typer.Exit(code=1)
 
 
@@ -3141,6 +3337,72 @@ def update_betterleaks(
         raise typer.Exit(code=1)
 
 
+@agent_app.command("update-skill-scanner")
+def update_skill_scanner(
+    version: str = typer.Option(
+        None,
+        "--version",
+        help="skill-scanner version to install (default: pinned version)",
+    ),
+):
+    """Install or update the optional `skill-scanner` deep engine (audit-skill --deep).
+
+    Installs Cisco AI Defense's skill-scanner in an isolated environment (uv tool,
+    or pip --user fallback). This is a heavy third-party package and its
+    transitive dependencies; it is NOT bundled with Rafter and is only used when
+    you pass --deep. The deep engine still runs OFFLINE analyzers only.
+    """
+    from ..scanners.skill_scanner import (
+        SkillScannerInstaller,
+        SKILL_SCANNER_VERSION,
+    )
+
+    target_version = version or SKILL_SCANNER_VERSION
+    installer = SkillScannerInstaller()
+
+    existing = shutil.which("skill-scanner")
+    if existing:
+        rprint(fmt.info(f"Current skill-scanner: {existing}"))
+    else:
+        rprint(fmt.info("skill-scanner not currently on PATH"))
+
+    rprint(fmt.warning(
+        "skill-scanner is a heavy third-party package (pulls litellm, fastapi, "
+        "yara-x, …). Installing it in an isolated environment."
+    ))
+    rprint(fmt.info(f"Installing skill-scanner v{target_version}..."))
+    rprint()
+
+    result = installer.install(version=target_version, on_progress=typer.echo)
+    rprint()
+    if not result.ok:
+        rprint(fmt.error(f"Install failed: {result.message}"))
+        rprint(fmt.info(
+            "To fix: install manually with `uv tool install "
+            "cisco-ai-skill-scanner` (or `pip install --user "
+            "cisco-ai-skill-scanner`) and ensure `skill-scanner` is on PATH."
+        ))
+        raise typer.Exit(code=1)
+
+    rprint(fmt.success(f"skill-scanner installed (via {result.via}): {result.message}"))
+    rprint(fmt.info("Run `rafter skill review <path> --deep` to use it."))
+
+
+@agent_app.command("remove-skill-scanner")
+def remove_skill_scanner():
+    """Uninstall the optional `skill-scanner` deep engine (inverse of update-skill-scanner).
+
+    Removes the managed install (uv tool, or pip fallback). Safe to run when it
+    isn't installed. Your skills and Rafter's own dependencies are untouched.
+    """
+    from ..scanners.skill_scanner import SkillScannerInstaller
+
+    result = SkillScannerInstaller().uninstall(on_progress=typer.echo)
+    rprint()
+    if not result.ok:
+        rprint(fmt.error(f"Uninstall failed: {result.message}"))
+        raise typer.Exit(code=1)
+    rprint(fmt.success(f"skill-scanner removed: {result.message}"))
 
 
 # ── agent status ─────────────────────────────────────────────────────────

{rafter_cli-0.8.7 → rafter_cli-0.8.9}/rafter_cli/commands/hook.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import json
+import math
 import os
 import subprocess
 import sys
@@ -52,6 +53,23 @@ def _format_approval_message(command: str, evaluation) -> str:
 
 _STDIN_TIMEOUT_S = 5
 
+def _stdin_timeout_s() -> float:
+    # Bound the stdin read so a hung/never-closing stdin can't wedge the hook.
+    # Overridable via env (milliseconds, parity with the Node hook) as an
+    # operator safety valve / for tests.
+    raw = os.environ.get("RAFTER_HOOK_STDIN_TIMEOUT_MS")
+    if raw:
+        try:
+            ms = float(raw)
+            # Require finite and positive (parity with the Node `Number.isFinite`
+            # check). `inf`/`nan` must NOT pass — `join(timeout=inf)` would
+            # reintroduce the exact unbounded hang this bound exists to prevent.
+            if math.isfinite(ms) and ms > 0:
+                return ms / 1000.0
+        except ValueError:
+            pass
+    return _STDIN_TIMEOUT_S
+
 def _read_stdin() -> str:
     import threading
     result: list[str] = [""]
@@ -60,9 +78,11 @@ def _read_stdin() -> str:
             result[0] = sys.stdin.read()
         except Exception:
             pass
+    # daemon=True: if stdin never closes, the abandoned reader thread does not
+    # block interpreter exit, so the process exits after the join timeout.
     t = threading.Thread(target=_reader, daemon=True)
     t.start()
-    t.join(timeout=_STDIN_TIMEOUT_S)
+    t.join(timeout=_stdin_timeout_s())
     return result[0]
 
 
@@ -256,27 +276,23 @@ def _scan_staged_files() -> dict:
         ).stdout.strip() or os.getcwd()
 
         output = subprocess.run(
-            ["git", "diff", "--cached", "--name-only", "--diff-filter=ACM"],
+            ["git", "diff", "-U0", "--no-color", "--cached", "--diff-filter=ACM"],
             capture_output=True, text=True,
-        ).stdout.strip()
-        if not output:
+        ).stdout
+        if not output.strip():
             return {**empty, "repo_root": repo_root}
-        staged = [f for f in output.split("\n") if f.strip()]
 
+        from ..utils.git_diff import parse_unified_diff_added_lines
+        from ..scanners.git_diff_scan import scan_added_diff_lines
         from ..core.custom_patterns import apply_suppressions
         from .agent import _apply_exclude_paths
 
+        added = parse_unified_diff_added_lines(output)
+        if not added:
+            return {**empty, "repo_root": repo_root}
+
         scan_cfg, suppressions, custom_patterns = _load_scan_config()
-        scanner = RegexScanner(custom_patterns)
-
-        raw = []
-        for f in staged:
-            resolved = os.path.join(repo_root, f)
-            if not os.path.isfile(resolved):
-                continue
-            r = scanner.scan_file(resolved)
-            if r.matches:
-                raw.append(r)
+        raw = scan_added_diff_lines(added, repo_root, custom_patterns)
 
         exclude = scan_cfg.exclude_paths if scan_cfg else None
         after_exclude = _apply_exclude_paths(raw, exclude, repo_root)