wrg-devguard 0.1.0__py3-none-any.whl

wrg_devguard/__init__.py

@@ -0,0 +1,6 @@
+"""wrg_devguard package."""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+

wrg_devguard/cli.py

@@ -0,0 +1,423 @@
+from __future__ import annotations
+
+import argparse
+import fnmatch
+import json
+from datetime import datetime, timezone
+from pathlib import Path, PurePosixPath
+from typing import Any
+
+from .policy import lint_policy, load_policy
+from .secrets import scan_secrets
+from .common import Finding, write_json
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="wrg-devguard")
+    sub = parser.add_subparsers(dest="command")
+
+    lint = sub.add_parser("lint-policy", help="scan content against policy deny patterns")
+    lint.add_argument("--path", default=".", help="scan root path")
+    lint.add_argument("--policy", default=None, help="policy file (json/toml/yaml)")
+    lint.add_argument("--profile", choices=["baseline", "strict"], default=None, help="use a predefined policy profile")
+    lint.add_argument("--paths-file", default=None, dest="paths_file", help="newline-delimited relative file list")
+    lint.add_argument("--allowlist", default=None, help="allowlist file path (json)")
+    lint.add_argument("--json-out", default=None, dest="json_out", help="write JSON report")
+    lint.add_argument("--fail-on", choices=["error", "warning"], default="error")
+
+    sec = sub.add_parser("scan-secrets", help="scan for common secret leak patterns")
+    sec.add_argument("--path", default=".", help="scan root path")
+    sec.add_argument("--paths-file", default=None, dest="paths_file", help="newline-delimited relative file list")
+    sec.add_argument("--allowlist", default=None, help="allowlist file path (json)")
+    sec.add_argument("--json-out", default=None, dest="json_out", help="write JSON report")
+    sec.add_argument("--fail-on", choices=["error", "warning"], default="error")
+
+    check = sub.add_parser("check", help="run lint-policy + scan-secrets")
+    check.add_argument("--path", default=".", help="scan root path")
+    check.add_argument("--policy", default=None, help="policy file (json/toml/yaml)")
+    check.add_argument("--profile", choices=["baseline", "strict"], default=None, help="use a predefined policy profile")
+    check.add_argument("--paths-file", default=None, dest="paths_file", help="newline-delimited relative file list")
+    check.add_argument("--allowlist", default=None, help="allowlist file path (json)")
+    check.add_argument("--json-out", default=None, dest="json_out", help="write JSON report")
+    check.add_argument("--fail-on", choices=["error", "warning"], default="error")
+
+    prof = sub.add_parser("profiles", help="list available policy profiles")
+    prof.add_argument("--path", default=".", help="repo root to inspect")
+
+    bandit_p = sub.add_parser("bandit", help="run bandit security scanner on Python source")
+    bandit_p.add_argument("--path", default=".", help="scan root path")
+    bandit_p.add_argument("--app", help="scan specific app under apps/<app>/")
+    bandit_p.add_argument("--severity", choices=["low", "medium", "high"], default="medium",
+                          help="minimum severity to report (default: medium)")
+    bandit_p.add_argument("--json-out", default=None, dest="json_out", help="write JSON report")
+
+    return parser
+
+
+def _should_fail(findings: list[Finding], fail_on: str) -> bool:
+    if fail_on == "warning":
+        return len(findings) > 0
+    return any(item.severity.upper() == "ERROR" for item in findings)
+
+
+def _safe_finding_dict(item: Finding) -> dict[str, Any]:
+    return {
+        "check": item.check,
+        "rule_id": item.rule_id,
+        "severity": item.severity,
+        "message": item.message,
+        "file": item.file,
+        "line": item.line,
+        "column": item.column,
+        # Never persist potentially sensitive matched text.
+        "snippet": "[REDACTED]",
+    }
+
+
+def _safe_finding_mapping(item: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "check": str(item.get("check", "")),
+        "rule_id": str(item.get("rule_id", "")),
+        "severity": str(item.get("severity", "")),
+        "message": str(item.get("message", "")),
+        "file": str(item.get("file", "")),
+        "line": int(item.get("line", 0)),
+        "column": int(item.get("column", 0)),
+        "snippet": "[REDACTED]",
+    }
+
+
+def _sanitize_suppressed_payload(items: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    sanitized: list[dict[str, Any]] = []
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        entry: dict[str, Any] = dict(item)
+        finding_obj = entry.get("finding")
+        if isinstance(finding_obj, dict):
+            entry["finding"] = _safe_finding_mapping(finding_obj)
+        sanitized.append(entry)
+    return sanitized
+
+
+def _as_report(
+    command: str,
+    root: Path,
+    findings: list[Finding],
+    fail_on: str,
+    suppressed: list[dict] | None = None,
+) -> dict:
+    suppressed_items = _sanitize_suppressed_payload(suppressed or [])
+    error_count = sum(1 for item in findings if item.severity.upper() == "ERROR")
+    warning_count = sum(1 for item in findings if item.severity.upper() == "WARNING")
+    status = "FAIL" if _should_fail(findings, fail_on) else "PASS"
+    return {
+        "schema_version": "wrg_devguard.v1",
+        "command": command,
+        "created_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+        "scan_root": str(root),
+        "status": status,
+        "summary": {
+            "total_findings": len(findings),
+            "error": error_count,
+            "warning": warning_count,
+            "suppressed": len(suppressed_items),
+            "fail_on": fail_on,
+        },
+        "findings": [_safe_finding_dict(item) for item in findings],
+        "suppressed": suppressed_items,
+    }
+
+
+def _print_summary(command: str) -> None:
+    print(f"{command}: completed (finding details are redacted by design)")
+
+
+def _safe_json_report(command: str, root: Path) -> dict[str, Any]:
+    return {
+        "schema_version": "wrg_devguard.v1",
+        "command": command,
+        "created_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+        "scan_root": str(root),
+        "status": "REDACTED",
+        "summary": {
+            "total_findings": "REDACTED",
+            "error": "REDACTED",
+            "warning": "REDACTED",
+            "suppressed": "REDACTED",
+            "fail_on": "REDACTED",
+        },
+        "findings": [],
+        "suppressed": [],
+    }
+
+
+def _normalize_rel_path(value: str) -> str:
+    text = value.strip().replace("\\", "/")
+    if text.startswith("./"):
+        text = text[2:]
+    return PurePosixPath(text).as_posix()
+
+
+def _load_allowed_files(paths_file: str | None, scan_root: Path) -> set[str] | None:
+    if not paths_file:
+        return None
+    candidate = Path(paths_file).resolve()
+    if not candidate.exists():
+        raise ValueError(f"paths file not found: {candidate}")
+
+    allowed: set[str] = set()
+    for raw in candidate.read_text(encoding="utf-8", errors="ignore").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#"):
+            continue
+        path_value = Path(line)
+        if path_value.is_absolute():
+            try:
+                normalized = path_value.resolve().relative_to(scan_root).as_posix()
+            except Exception:
+                continue
+        else:
+            normalized = _normalize_rel_path(line)
+        allowed.add(normalized)
+    return allowed
+
+
+def _load_allowlist(allowlist_arg: str | None, scan_root: Path) -> list[dict]:
+    if allowlist_arg:
+        candidate = Path(allowlist_arg).resolve()
+    else:
+        candidate = scan_root / ".wrg" / "allowlist.json"
+    if not candidate.exists():
+        return []
+    try:
+        payload = json.loads(candidate.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"allowlist file is not valid json: {candidate}") from exc
+    if not isinstance(payload, dict):
+        return []
+    rules = payload.get("rules")
+    if not isinstance(rules, list):
+        return []
+    return [item for item in rules if isinstance(item, dict)]
+
+
+def _finding_matches_rule(finding: Finding, rule: dict) -> bool:
+    check = rule.get("check")
+    rule_id = rule.get("rule_id")
+    severity = rule.get("severity")
+    file_pattern = rule.get("file")
+    snippet_contains = rule.get("snippet_contains")
+
+    if isinstance(check, str) and check.strip() and finding.check != check.strip():
+        return False
+    if isinstance(rule_id, str) and rule_id.strip() and finding.rule_id != rule_id.strip():
+        return False
+    if isinstance(severity, str) and severity.strip() and finding.severity.upper() != severity.strip().upper():
+        return False
+    if isinstance(file_pattern, str) and file_pattern.strip():
+        if not fnmatch.fnmatch(finding.file, file_pattern.strip()):
+            return False
+    if isinstance(snippet_contains, str) and snippet_contains.strip():
+        if snippet_contains not in finding.snippet:
+            return False
+    return True
+
+
+def _apply_allowlist(findings: list[Finding], allowlist_rules: list[dict]) -> tuple[list[Finding], list[dict]]:
+    if not allowlist_rules:
+        return findings, []
+    active: list[Finding] = []
+    suppressed: list[dict] = []
+    for finding in findings:
+        matched_rule = None
+        for rule in allowlist_rules:
+            if _finding_matches_rule(finding, rule):
+                matched_rule = rule
+                break
+        if matched_rule is None:
+            active.append(finding)
+            continue
+        suppressed.append(
+            {
+                "finding": _safe_finding_dict(finding),
+                "reason": str(matched_rule.get("reason", "allowlisted")),
+                "rule": {
+                    "check": matched_rule.get("check"),
+                    "rule_id": matched_rule.get("rule_id"),
+                    "file": matched_rule.get("file"),
+                },
+            }
+        )
+    return active, suppressed
+
+
+def _resolve_policy_argument(policy_arg: str | None, profile: str | None, scan_root: Path) -> str | None:
+    if policy_arg and profile:
+        raise ValueError("use either --policy or --profile, not both")
+    if policy_arg:
+        return policy_arg
+    if profile is None:
+        return None
+    if profile == "baseline":
+        candidate = scan_root / ".wrg" / "policy.json"
+    else:
+        candidate = scan_root / ".wrg" / "policy.strict.json"
+    if not candidate.exists():
+        raise ValueError(f"profile policy file not found: {candidate}")
+    return str(candidate)
+
+
+def _run_bandit(args: argparse.Namespace) -> int:
+    """Run bandit security scanner on Python source."""
+    import subprocess
+    import sys
+
+    target = Path(args.path).resolve()
+    if args.app:
+        target = target / "apps" / args.app / "src"
+        if not target.exists():
+            target = Path(args.path).resolve() / "apps" / args.app
+    if not target.exists():
+        print(f"ERROR: path not found: {target}", file=sys.stderr)
+        return 1
+
+    sev_map = {"low": "l", "medium": "m", "high": "h"}
+    sev_flag = sev_map.get(args.severity, "m")
+
+    cmd = ["bandit", "-r", str(target), f"-l{sev_flag}", "-f", "json", "-q"]
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
+    except FileNotFoundError:
+        print("ERROR: bandit not installed. Run: pip install bandit", file=sys.stderr)
+        return 1
+
+    if args.json_out:
+        Path(args.json_out).write_text(result.stdout or "{}", encoding="utf-8")
+        print(f"Report written to {args.json_out}")
+    elif result.stdout:
+        try:
+            data = json.loads(result.stdout)
+            issues = data.get("results", [])
+            if not issues:
+                print(f"bandit: no issues found (severity >= {args.severity})")
+                return 0
+            print(f"bandit: {len(issues)} issue(s) found (severity >= {args.severity})\n")
+            for issue in issues:
+                sev = issue.get("issue_severity", "?")
+                conf = issue.get("issue_confidence", "?")
+                text = issue.get("issue_text", "?")
+                fname = issue.get("filename", "?")
+                line = issue.get("line_number", "?")
+                print(f"  [{sev}/{conf}] {fname}:{line}")
+                print(f"    {text}\n")
+        except json.JSONDecodeError:
+            print(result.stdout)
+    else:
+        print(f"bandit: no issues found (severity >= {args.severity})")
+        return 0
+
+    return 1 if result.returncode != 0 else 0
+
+
+def _run_profiles(scan_root: Path) -> int:
+    baseline = scan_root / ".wrg" / "policy.json"
+    strict = scan_root / ".wrg" / "policy.strict.json"
+    print("wrg-devguard profiles:")
+    print(f"- baseline: {baseline} | {'present' if baseline.exists() else 'missing'}")
+    print(f"- strict:   {strict} | {'present' if strict.exists() else 'missing'}")
+    return 0
+
+
+def _run_lint_policy(
+    scan_root: Path,
+    policy_arg: str | None,
+    fail_on: str,
+    allowed_files: set[str] | None,
+    allowlist_rules: list[dict],
+) -> tuple[dict, int]:
+    policy = load_policy(policy_arg, scan_root)
+    findings = lint_policy(scan_root, policy, allowed_files=allowed_files)
+    findings, suppressed = _apply_allowlist(findings, allowlist_rules)
+    report = _as_report("lint-policy", scan_root, findings, fail_on, suppressed=suppressed)
+    _print_summary("lint-policy")
+    return report, (1 if report["status"] == "FAIL" else 0)
+
+
+def _run_scan_secrets(
+    scan_root: Path,
+    fail_on: str,
+    allowed_files: set[str] | None,
+    allowlist_rules: list[dict],
+) -> tuple[dict, int]:
+    findings = scan_secrets(scan_root, allowed_files=allowed_files)
+    findings, suppressed = _apply_allowlist(findings, allowlist_rules)
+    report = _as_report("scan-secrets", scan_root, findings, fail_on, suppressed=suppressed)
+    _print_summary("scan-secrets")
+    return report, (1 if report["status"] == "FAIL" else 0)
+
+
+def _run_check(
+    scan_root: Path,
+    policy_arg: str | None,
+    fail_on: str,
+    allowed_files: set[str] | None,
+    allowlist_rules: list[dict],
+) -> tuple[dict, int]:
+    policy = load_policy(policy_arg, scan_root)
+    policy_findings = lint_policy(scan_root, policy, allowed_files=allowed_files)
+    secret_findings = scan_secrets(scan_root, allowed_files=allowed_files)
+    findings, suppressed = _apply_allowlist([*policy_findings, *secret_findings], allowlist_rules)
+    report = _as_report("check", scan_root, findings, fail_on, suppressed=suppressed)
+    _print_summary("check")
+    return report, (1 if report["status"] == "FAIL" else 0)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if args.command is None:
+        parser.print_help()
+        return 1
+
+    scan_root = Path(args.path).resolve()
+    if not scan_root.exists():
+        print(f"scan path does not exist: {scan_root}")
+        return 2
+
+    if args.command == "profiles":
+        return _run_profiles(scan_root)
+
+    if args.command == "bandit":
+        return _run_bandit(args)
+
+    try:
+        allowed_files = _load_allowed_files(args.paths_file, scan_root)
+        allowlist_rules = _load_allowlist(getattr(args, "allowlist", None), scan_root)
+        resolved_policy = _resolve_policy_argument(
+            getattr(args, "policy", None),
+            getattr(args, "profile", None),
+            scan_root,
+        )
+    except ValueError as exc:
+        print(str(exc))
+        return 2
+
+    if args.command == "lint-policy":
+        report, exit_code = _run_lint_policy(scan_root, resolved_policy, args.fail_on, allowed_files, allowlist_rules)
+    elif args.command == "scan-secrets":
+        report, exit_code = _run_scan_secrets(scan_root, args.fail_on, allowed_files, allowlist_rules)
+    elif args.command == "check":
+        report, exit_code = _run_check(scan_root, resolved_policy, args.fail_on, allowed_files, allowlist_rules)
+    else:
+        parser.print_help()
+        return 1
+
+    if args.json_out:
+        write_json(args.json_out, _safe_json_report(args.command, scan_root))
+    return exit_code
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

wrg_devguard/common.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import json
+import fnmatch
+import re
+from dataclasses import asdict, dataclass
+from pathlib import Path, PurePosixPath
+from typing import Iterable
+
+
+@dataclass
+class Finding:
+    check: str
+    rule_id: str
+    severity: str
+    message: str
+    file: str
+    line: int
+    column: int
+    snippet: str
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+def to_posix(path: Path) -> str:
+    return path.as_posix()
+
+
+def relative_posix(path: Path, root: Path) -> str:
+    return to_posix(path.relative_to(root))
+
+
+def match_any(path: str, patterns: Iterable[str]) -> bool:
+    pp = PurePosixPath(path)
+    for pattern in patterns:
+        if fnmatch.fnmatch(path, pattern):
+            return True
+        if pp.match(pattern):
+            return True
+        if pattern.startswith("**/"):
+            if pp.match(pattern[3:]):
+                return True
+    return False
+
+
+def read_text_safely(path: Path, max_bytes: int = 1_048_576) -> str:
+    if path.stat().st_size > max_bytes:
+        return ""
+    return path.read_text(encoding="utf-8", errors="ignore")
+
+
+def line_col(text: str, index: int) -> tuple[int, int]:
+    line = text.count("\n", 0, index) + 1
+    line_start = text.rfind("\n", 0, index)
+    column = index + 1 if line_start == -1 else index - line_start
+    return line, column
+
+
+def clean_snippet(value: str) -> str:
+    return re.sub(r"\s+", " ", value).strip()[:200]
+
+
+def write_json(path: str | Path, payload: dict) -> None:
+    output_path = Path(path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(json.dumps(payload, indent=2, ensure_ascii=False), encoding="utf-8")

wrg_devguard/policy.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+from .common import Finding, line_col, match_any, read_text_safely, relative_posix
+
+DEFAULT_INCLUDE = [
+    "**/*.md",
+    "**/*.txt",
+    "**/*.prompt",
+    "**/*.yaml",
+    "**/*.yml",
+    "**/*.json",
+    "**/*.py",
+]
+
+DEFAULT_EXCLUDE = [
+    "**/.git/**",
+    "**/.venv/**",
+    "**/venv/**",
+    "**/node_modules/**",
+    "**/__pycache__/**",
+    "**/.pytest_cache/**",
+    "**/tests/**",
+    "**/testdata/**",
+    "**/fixtures/**",
+    "**/.tmp/**",
+    ".tmp/**",
+    "**/.tmp_pytest/**",
+    ".tmp_pytest/**",
+    "**/_tmp*/**",
+    "_tmp*/**",
+    "**/.cache/**",
+    "**/site-packages/**",
+    "**/.train_venv/**",
+    "**/data/**",
+    "**/runs/**",
+    "**/artifacts/**",
+    "artifacts/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/*.png",
+    "**/*.jpg",
+    "**/*.jpeg",
+    "**/*.gif",
+    "**/*.svg",
+    "**/*.ico",
+    "**/*.lock",
+]
+
+DEFAULT_DENY_PATTERNS = [
+    {
+        "id": "prompt_injection_ignore_previous",
+        "regex": r"ignore\s+previous\s+instructions",
+        "severity": "ERROR",
+        "message": "Potential prompt-injection control bypass.",
+    },
+    {
+        "id": "prompt_injection_bypass_guardrails",
+        "regex": r"bypass\s+(all\s+)?(safety|guardrails|policy|policies)",
+        "severity": "ERROR",
+        "message": "Potential policy bypass intent.",
+    },
+    {
+        "id": "data_exfiltration_intent",
+        "regex": r"(exfiltrate|leak|dump)\s+.*(secret|credential|token|password)",
+        "severity": "ERROR",
+        "message": "Potential exfiltration intent in prompt content.",
+    },
+]
+
+
+def default_policy() -> dict:
+    return {
+        "include": list(DEFAULT_INCLUDE),
+        "exclude": list(DEFAULT_EXCLUDE),
+        "max_file_bytes": 1_048_576,
+        "deny_patterns": list(DEFAULT_DENY_PATTERNS),
+    }
+
+
+def _parse_policy_file(policy_path: Path) -> dict:
+    suffix = policy_path.suffix.lower()
+    content = policy_path.read_text(encoding="utf-8")
+    if suffix == ".json":
+        return json.loads(content)
+    if suffix == ".toml":
+        import tomllib
+
+        return tomllib.loads(content)
+    if suffix in {".yaml", ".yml"}:
+        try:
+            import yaml  # type: ignore
+        except ModuleNotFoundError as exc:
+            raise ValueError(
+                "YAML policy requested but PyYAML is not installed. Install with: pip install -e \".[yaml]\""
+            ) from exc
+        payload = yaml.safe_load(content)
+        return payload if isinstance(payload, dict) else {}
+    return json.loads(content)
+
+
+def load_policy(policy_arg: str | None, repo_root: Path) -> dict:
+    if policy_arg:
+        candidate = Path(policy_arg).resolve()
+        if not candidate.exists():
+            raise ValueError(f"Policy file not found: {candidate}")
+        parsed = _parse_policy_file(candidate)
+    else:
+        default_path = repo_root / ".wrg" / "policy.json"
+        parsed = _parse_policy_file(default_path) if default_path.exists() else {}
+
+    policy = default_policy()
+    if not isinstance(parsed, dict):
+        return policy
+
+    include = parsed.get("include")
+    exclude = parsed.get("exclude")
+    deny_patterns = parsed.get("deny_patterns")
+    max_file_bytes = parsed.get("max_file_bytes")
+
+    if isinstance(include, list) and include:
+        policy["include"] = [str(item) for item in include if isinstance(item, str) and item.strip()]
+    if isinstance(exclude, list) and exclude:
+        policy["exclude"] = [str(item) for item in exclude if isinstance(item, str) and item.strip()]
+    if isinstance(deny_patterns, list) and deny_patterns:
+        normalized = []
+        for item in deny_patterns:
+            if not isinstance(item, dict):
+                continue
+            regex = item.get("regex")
+            if not isinstance(regex, str) or not regex.strip():
+                continue
+            normalized.append(
+                {
+                    "id": str(item.get("id", "custom_pattern")),
+                    "regex": regex,
+                    "severity": str(item.get("severity", "ERROR")).upper(),
+                    "message": str(item.get("message", "Custom deny pattern matched.")),
+                }
+            )
+        if normalized:
+            policy["deny_patterns"] = normalized
+    if isinstance(max_file_bytes, int) and max_file_bytes > 0:
+        policy["max_file_bytes"] = max_file_bytes
+    return policy
+
+
+def _iter_candidate_files(root: Path, include: list[str], exclude: list[str]) -> list[Path]:
+    return _iter_candidate_files_filtered(root, include, exclude, allowed_files=None)
+
+
+def _iter_candidate_files_filtered(
+    root: Path,
+    include: list[str],
+    exclude: list[str],
+    allowed_files: set[str] | None,
+) -> list[Path]:
+    results: list[Path] = []
+    for path in root.rglob("*"):
+        if not path.is_file():
+            continue
+        rel = relative_posix(path, root)
+        if allowed_files is not None and rel not in allowed_files:
+            continue
+        if match_any(rel, exclude):
+            continue
+        if not match_any(rel, include):
+            continue
+        results.append(path)
+    return results
+
+
+def lint_policy(root: Path, policy: dict, allowed_files: set[str] | None = None) -> list[Finding]:
+    findings: list[Finding] = []
+    include = policy.get("include", DEFAULT_INCLUDE)
+    exclude = policy.get("exclude", DEFAULT_EXCLUDE)
+    max_file_bytes = int(policy.get("max_file_bytes", 1_048_576))
+    deny_patterns = policy.get("deny_patterns", DEFAULT_DENY_PATTERNS)
+    candidates = _iter_candidate_files_filtered(root, include, exclude, allowed_files)
+
+    compiled_patterns = []
+    for rule in deny_patterns:
+        if not isinstance(rule, dict):
+            continue
+        try:
+            compiled_patterns.append(
+                (
+                    str(rule.get("id", "unknown_rule")),
+                    re.compile(str(rule.get("regex", "")), re.IGNORECASE | re.MULTILINE),
+                    str(rule.get("severity", "ERROR")).upper(),
+                    str(rule.get("message", "Policy deny pattern matched.")),
+                )
+            )
+        except re.error:
+            continue
+
+    for path in candidates:
+        text = read_text_safely(path, max_bytes=max_file_bytes)
+        if not text:
+            continue
+        rel = relative_posix(path, root)
+        for rule_id, regex, severity, message in compiled_patterns:
+            for match in regex.finditer(text):
+                line, column = line_col(text, match.start())
+                findings.append(
+                    Finding(
+                        check="lint-policy",
+                        rule_id=rule_id,
+                        severity=severity,
+                        message=message,
+                        file=rel,
+                        line=line,
+                        column=column,
+                        # Never retain matched content in memory or output payloads.
+                        snippet="[REDACTED]",
+                    )
+                )
+    return findings

wrg_devguard/secrets.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from .common import Finding, line_col, match_any, read_text_safely, relative_posix
+from .policy import DEFAULT_EXCLUDE
+
+SECRET_RULES = [
+    {
+        "id": "openai_api_key",
+        "regex": r"\bsk-(?:proj-)?[A-Za-z0-9_-]{20,}\b",
+        "severity": "ERROR",
+        "message": "Possible OpenAI API key found.",
+    },
+    {
+        "id": "github_token",
+        "regex": r"\bgh[pousr]_[A-Za-z0-9]{36,255}\b",
+        "severity": "ERROR",
+        "message": "Possible GitHub token found.",
+    },
+    {
+        "id": "aws_access_key_id",
+        "regex": r"\bAKIA[0-9A-Z]{16}\b",
+        "severity": "ERROR",
+        "message": "Possible AWS Access Key ID found.",
+    },
+    {
+        "id": "slack_token",
+        "regex": r"\bxox[baprs]-[A-Za-z0-9-]{10,}\b",
+        "severity": "ERROR",
+        "message": "Possible Slack token found.",
+    },
+    {
+        "id": "private_key_block",
+        "regex": r"-----BEGIN (?:RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----",
+        "severity": "ERROR",
+        "message": "Private key block found.",
+    },
+    {
+        "id": "generic_secret_assignment",
+        "regex": r"(?i)(api[_-]?key|access[_-]?token|secret|password)\s*[:=]\s*['\"][^'\"]{8,}['\"]",
+        "severity": "WARNING",
+        "message": "Potential hardcoded secret assignment.",
+    },
+]
+
+DEFAULT_INCLUDE = [
+    "**/*.env",
+    "**/*.ini",
+    "**/*.json",
+    "**/*.toml",
+    "**/*.yaml",
+    "**/*.yml",
+    "**/*.txt",
+    "**/*.md",
+    "**/*.py",
+    "**/*.js",
+    "**/*.ts",
+    "**/*.sh",
+    "**/*.ps1",
+]
+
+
+def scan_secrets(
+    root: Path,
+    max_file_bytes: int = 1_048_576,
+    allowed_files: set[str] | None = None,
+) -> list[Finding]:
+    findings: list[Finding] = []
+    compiled_rules = [
+        (
+            rule["id"],
+            re.compile(rule["regex"], re.MULTILINE),
+            rule["severity"],
+            rule["message"],
+        )
+        for rule in SECRET_RULES
+    ]
+
+    for path in root.rglob("*"):
+        if not path.is_file():
+            continue
+        rel = relative_posix(path, root)
+        if allowed_files is not None and rel not in allowed_files:
+            continue
+        if match_any(rel, DEFAULT_EXCLUDE):
+            continue
+        if not match_any(rel, DEFAULT_INCLUDE):
+            continue
+        text = read_text_safely(path, max_bytes=max_file_bytes)
+        if not text:
+            continue
+        for rule_id, regex, severity, message in compiled_rules:
+            for match in regex.finditer(text):
+                line, column = line_col(text, match.start())
+                findings.append(
+                    Finding(
+                        check="scan-secrets",
+                        rule_id=rule_id,
+                        severity=severity,
+                        message=message,
+                        file=rel,
+                        line=line,
+                        column=column,
+                        # Never retain matched secret value in memory or output payloads.
+                        snippet="[REDACTED]",
+                    )
+                )
+    return findings

wrg_devguard-0.1.0.dist-info/METADATA

@@ -0,0 +1,197 @@
+Metadata-Version: 2.4
+Name: wrg-devguard
+Version: 0.1.0
+Summary: Developer-first AI safety checks: prompt-policy lint + secret scanning. Zero-dep CLI + GitHub Action + Claude Skill + Cursor Rule.
+Author: Yakuphan Yucel
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yakuphanycl/wrg-devguard
+Project-URL: Repository, https://github.com/yakuphanycl/wrg-devguard
+Project-URL: Issues, https://github.com/yakuphanycl/wrg-devguard/issues
+Project-URL: Changelog, https://github.com/yakuphanycl/wrg-devguard/releases
+Keywords: security,secret-scanning,policy-lint,ai-safety,prompt-security,devsecops,pre-commit,github-action,claude-skill,cursor-rule
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: yaml
+Requires-Dist: PyYAML>=6.0; extra == "yaml"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Dynamic: license-file
+
+# wrg-devguard
+
+**Developer-first AI safety checks: prompt-policy lint + secret scanning.**
+
+Zero-dependency Python CLI that scans a repository for two classes of issues
+before your PR lands:
+
+1. **Leaked secrets** — API keys, private keys, tokens, common credential
+   formats in tracked files.
+2. **Prompt-policy violations** — deny-listed patterns in prompts, system
+   messages, and AI-facing text assets (configurable via JSON policy).
+
+Ships as:
+
+- A Python package (`pip install wrg-devguard`)
+- A GitHub Action (drop-in composite action for any repo)
+- A Claude Code skill (`.claude/skills/wrg-devguard/`)
+- A Cursor rule (`.cursor/rules/wrg-devguard.mdc`)
+
+No external dependencies in the core scanner (stdlib only). Optional `[yaml]`
+extra for YAML policy files. Optional `bandit` subcommand for Python security
+scanning.
+
+## Install
+
+```bash
+pip install wrg-devguard
+```
+
+For YAML policy support:
+
+```bash
+pip install "wrg-devguard[yaml]"
+```
+
+## Quick start
+
+```bash
+# Run both checks and fail on any high-severity finding
+wrg-devguard check --path . --fail-on error
+
+# Scan only for leaked secrets
+wrg-devguard scan-secrets --path .
+
+# Lint AI-facing text assets against a policy
+wrg-devguard lint-policy --path . --profile strict
+
+# Emit a JSON report for CI
+wrg-devguard check --path . --json-out wrg-devguard-report.json
+```
+
+## GitHub Action
+
+```yaml
+# .github/workflows/security.yml
+name: security
+on: [pull_request, push]
+
+jobs:
+  wrg-devguard:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: yakuphanycl/wrg-devguard@v1
+        with:
+          profile: strict
+          fail-on: error
+```
+
+See [`action.yml`](./action.yml) for all inputs.
+
+## Claude Code skill
+
+Drop the skill into your workspace:
+
+```bash
+mkdir -p .claude/skills/wrg-devguard
+curl -L https://raw.githubusercontent.com/yakuphanycl/wrg-devguard/main/.claude/skills/wrg-devguard/SKILL.md \
+  -o .claude/skills/wrg-devguard/SKILL.md
+```
+
+Claude Code will surface the skill automatically when you ask things like
+"scan for secrets", "is this safe to commit", or "check for leaks".
+
+## Cursor rule
+
+Drop the rule into your workspace:
+
+```bash
+mkdir -p .cursor/rules
+curl -L https://raw.githubusercontent.com/yakuphanycl/wrg-devguard/main/.cursor/rules/wrg-devguard.mdc \
+  -o .cursor/rules/wrg-devguard.mdc
+```
+
+Cursor will apply the rule before suggesting any `git commit` command.
+
+## Policy file
+
+Default lookup order:
+
+1. `--policy <path>` argument if provided
+2. `.wrg/policy.json` at the repo root
+3. Built-in defaults
+
+Profiles:
+
+- `default` → PR-friendly baseline (recommended for CI)
+- `strict` → stricter local/release audits (use `--profile strict`)
+
+Place custom policies in `.wrg/policy.json` (JSON) or `.wrg/policy.yaml`
+(requires `[yaml]` extra).
+
+## Commands
+
+```
+wrg-devguard profiles                           # list available profiles
+wrg-devguard lint-policy --path .               # policy lint only
+wrg-devguard scan-secrets --path .              # secret scan only
+wrg-devguard check --path .                     # both, single JSON report
+wrg-devguard check --path . --profile strict
+wrg-devguard check --path . --json-out report.json
+wrg-devguard check --path . --fail-on warning
+wrg-devguard check --path . --allowlist .wrg/allowlist.json
+wrg-devguard bandit --path src/                 # optional: bandit wrapper
+```
+
+## Exit codes
+
+- `0` — no findings above threshold
+- `1` — findings at or above `--fail-on` threshold
+- `2` — configuration or input error
+
+## Why another secret scanner?
+
+- **Zero runtime deps** — the core scanner is stdlib only, so `pip install` is
+  instant and works in any sandbox.
+- **Policy lint in the same tool** — most scanners only do secrets. We also
+  catch prompt-policy violations (deny-listed patterns, hardcoded system
+  prompts, PII in AI-facing text).
+- **AI-native UX** — ships with a Claude skill and a Cursor rule so the
+  scanner runs automatically inside your AI coding assistant, not just in CI.
+- **Stable JSON schema** — `check --json-out` emits a versioned schema that
+  never breaks.
+
+## Development
+
+```bash
+git clone https://github.com/yakuphanycl/wrg-devguard.git
+cd wrg-devguard
+pip install -e ".[dev]"
+pytest -q
+```
+
+## License
+
+MIT. See [LICENSE](./LICENSE).
+
+## Contributing
+
+Issues and PRs welcome. For substantial changes, open an issue first to
+discuss scope.
+
+---
+
+Part of the [WinstonRedGuard](https://github.com/yakuphanycl/WinstonRedGuard)
+ecosystem. The monorepo at `apps/wrg_devguard/` is the canonical source; this
+repo is a distribution mirror kept in sync on every release.

wrg_devguard-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+wrg_devguard/__init__.py,sha256=s3wNt6OeH5we3eksw3poTOZi4OnXZF9M8zyXZEVZUPc,88
+wrg_devguard/cli.py,sha256=bIzEd76EjkIEt0qoAS9L-xrGCOqXAZhRL49dCqdCGyI,16143
+wrg_devguard/common.py,sha256=qS8aBFrt1t_F15H4tgFlmD-WzdrloDcX2OLVmr-i0wY,1678
+wrg_devguard/policy.py,sha256=Y-KpuoLxCSNr2ZXz7b8W0iDnLkzgCMAEl5bfWN1WO2w,7094
+wrg_devguard/secrets.py,sha256=oRn5G4e1wOu6224c-KXZPJy30xhTiBiYXoCz4pzKfJE,3154
+wrg_devguard-0.1.0.dist-info/licenses/LICENSE,sha256=jrugCAfdds9cjUQmsxgTP9pw4JJ7EVEOkC3Wr4GxypQ,1086
+wrg_devguard-0.1.0.dist-info/METADATA,sha256=bmeQHBaTiIB1GETWRglheVLVP-QcG3ycHT5wTp5TbDU,6183
+wrg_devguard-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+wrg_devguard-0.1.0.dist-info/entry_points.txt,sha256=lRChmT2U5RHb-4hdnlXj-AXlAdUM2ITZ7MIXcL0DFdw,55
+wrg_devguard-0.1.0.dist-info/top_level.txt,sha256=27aZ5wNEi-pymjfa4pML11qqhuUkmwKEuwvkfGiwWQg,13
+wrg_devguard-0.1.0.dist-info/RECORD,,

wrg_devguard-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

wrg_devguard-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+wrg-devguard = wrg_devguard.cli:main

wrg_devguard-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yakuphan
+
+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.

wrg_devguard-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+wrg_devguard