@sentry/warden 0.35.0 → 0.36.0

package/skills/warden-sweep/scripts/extract_findings.py

@@ -1,219 +0,0 @@
-#!/usr/bin/env python3
-# /// script
-# requires-python = ">=3.9"
-# ///
-"""
-Extract individual findings from warden JSONL log files.
-
-Usage:
-    python extract_findings.py <log-path-or-directory> -o <output.jsonl>
-    python extract_findings.py .warden/logs/ --scan-index data/scan-index.jsonl -o findings.jsonl
-
-Reads warden JSONL logs (one skill record per line, summary as last line),
-extracts each finding as a standalone record with a stable ID, and writes
-one finding per line to the output file.
-
-Finding ID format: <skill>-<sha256(title+path+line)[:8]>
-"""
-from __future__ import annotations
-
-import argparse
-import hashlib
-import json
-import os
-import sys
-from pathlib import Path
-from typing import Any
-
-
-def generate_finding_id(skill: str, title: str, path: str, line: int | None) -> str:
-    """Generate a stable, deterministic finding ID."""
-    raw = f"{title}:{path}:{line or 0}"
-    digest = hashlib.sha256(raw.encode()).hexdigest()[:8]
-    # Sanitize skill name for use in ID
-    safe_skill = skill.replace("/", "-").replace(" ", "-").lower()
-    return f"{safe_skill}-{digest}"
-
-
-def parse_jsonl_log(log_path: str) -> list[dict[str, Any]]:
-    """Parse a warden JSONL log file and extract individual findings.
-
-    Each non-summary line has the shape:
-    {
-      "run": {...},
-      "skill": "...",
-      "findings": [{...}, ...],
-      ...
-    }
-
-    The last line is a summary record with "type": "summary" which we skip.
-    """
-    findings = []
-    try:
-        with open(log_path) as f:
-            for line in f:
-                line = line.strip()
-                if not line:
-                    continue
-                try:
-                    record = json.loads(line)
-                except json.JSONDecodeError:
-                    continue
-
-                # Skip summary records
-                if record.get("type") == "summary":
-                    continue
-
-                skill = record.get("skill", "unknown")
-                run_meta = record.get("run", {})
-                record_findings = record.get("findings", [])
-
-                for finding in record_findings:
-                    location = finding.get("location", {})
-                    file_path = location.get("path", "")
-                    start_line = location.get("startLine")
-                    end_line = location.get("endLine")
-
-                    finding_id = generate_finding_id(
-                        skill=skill,
-                        title=finding.get("title", ""),
-                        path=file_path,
-                        line=start_line,
-                    )
-
-                    normalized = {
-                        "findingId": finding_id,
-                        "file": file_path,
-                        "skill": skill,
-                        "severity": finding.get("severity", "info"),
-                        "confidence": finding.get("confidence"),
-                        "title": finding.get("title", ""),
-                        "description": finding.get("description", ""),
-                        "verification": finding.get("verification"),
-                        "location": {
-                            "path": file_path,
-                            "startLine": start_line,
-                            "endLine": end_line,
-                        },
-                        "suggestedFix": finding.get("suggestedFix"),
-                        "logPath": log_path,
-                        "runId": run_meta.get("runId", ""),
-                    }
-
-                    findings.append(normalized)
-
-    except (OSError, IOError) as e:
-        print(f"Error reading {log_path}: {e}", file=sys.stderr)
-
-    return findings
-
-
-def collect_log_paths(source: str, scan_index: str | None = None) -> list[str]:
-    """Collect log file paths from a directory or scan index."""
-    paths: list[str] = []
-
-    if scan_index and os.path.exists(scan_index):
-        # Read log paths from scan-index.jsonl
-        seen = set()
-        total_entries = 0
-        missing = 0
-        with open(scan_index) as f:
-            for line in f:
-                line = line.strip()
-                if not line:
-                    continue
-                try:
-                    entry = json.loads(line)
-                except json.JSONDecodeError:
-                    continue
-                if entry.get("status") != "complete":
-                    continue
-                total_entries += 1
-                log_path = entry.get("logPath", "")
-                if log_path and log_path not in seen:
-                    seen.add(log_path)
-                    if os.path.isfile(log_path):
-                        paths.append(log_path)
-                    else:
-                        missing += 1
-        if missing > 0:
-            print(
-                f"Warning: {missing} log path(s) from scan-index not found on disk",
-                file=sys.stderr,
-            )
-        # Only use scan-index results if we actually found logs;
-        # fall through to source directory otherwise
-        if paths:
-            return paths
-        if total_entries > 0:
-            print(
-                "Warning: scan-index had entries but no valid log paths; "
-                "falling back to source directory",
-                file=sys.stderr,
-            )
-
-    source_path = Path(source)
-    if source_path.is_file():
-        return [str(source_path)]
-
-    if source_path.is_dir():
-        for f in sorted(source_path.glob("*.jsonl")):
-            paths.append(str(f))
-        return paths
-
-    print(f"Source not found: {source}", file=sys.stderr)
-    return paths
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Extract findings from warden JSONL logs"
-    )
-    parser.add_argument(
-        "source",
-        help="Path to a JSONL log file or directory of log files",
-    )
-    parser.add_argument(
-        "-o", "--output",
-        required=True,
-        help="Output path for normalized findings JSONL",
-    )
-    parser.add_argument(
-        "--scan-index",
-        help="Path to scan-index.jsonl (uses log paths from completed scans)",
-    )
-    args = parser.parse_args()
-
-    log_paths = collect_log_paths(args.source, args.scan_index)
-    if not log_paths:
-        print("No log files found.", file=sys.stderr)
-        sys.exit(1)
-
-    all_findings: list[dict[str, Any]] = []
-    seen_ids: set[str] = set()
-
-    for log_path in log_paths:
-        findings = parse_jsonl_log(log_path)
-        for f in findings:
-            fid = f["findingId"]
-            if fid not in seen_ids:
-                seen_ids.add(fid)
-                all_findings.append(f)
-
-    # Write output
-    os.makedirs(os.path.dirname(os.path.abspath(args.output)), exist_ok=True)
-    with open(args.output, "w") as out:
-        for finding in all_findings:
-            out.write(json.dumps(finding) + "\n")
-
-    print(
-        json.dumps({
-            "logsProcessed": len(log_paths),
-            "findingsExtracted": len(all_findings),
-            "outputPath": args.output,
-        })
-    )
-
-
-if __name__ == "__main__":
-    main()

package/skills/warden-sweep/scripts/find_reviewers.py

@@ -1,114 +0,0 @@
-#!/usr/bin/env python3
-# /// script
-# requires-python = ">=3.9"
-# ///
-"""
-Find top git contributors for a file to use as PR reviewers.
-
-Usage:
-    python find_reviewers.py <file-path>
-    python find_reviewers.py src/foo.ts
-
-Output: JSON to stdout with GitHub usernames of top 2 contributors
-from the last 12 months.
-
-{"reviewers": ["user1", "user2"]}
-
-If no contributors found or mapping fails, returns empty list.
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import sys
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from _utils import run_cmd_stdout as run_cmd  # noqa: E402
-
-
-def get_top_authors(file_path: str, count: int = 2) -> list[str]:
-    """Get top N author emails for a file from git log (last 12 months)."""
-    output = run_cmd([
-        "git", "log",
-        "--format=%ae",
-        "--since=12 months ago",
-        "--", file_path,
-    ])
-
-    if not output:
-        return []
-
-    # Count occurrences of each email
-    email_counts: dict[str, int] = {}
-    for email in output.splitlines():
-        email = email.strip()
-        if email:
-            email_counts[email] = email_counts.get(email, 0) + 1
-
-    # Sort by count descending
-    sorted_emails = sorted(email_counts.items(), key=lambda x: x[1], reverse=True)
-
-    return [email for email, _ in sorted_emails[:count]]
-
-
-def email_to_github_username(email: str) -> str | None:
-    """Try to map a git email to a GitHub username.
-
-    Extracts from noreply emails directly. For other emails,
-    uses the GitHub search-by-email API via gh CLI.
-    """
-    # Handle GitHub noreply emails directly
-    if email.endswith("@users.noreply.github.com"):
-        # Format: 12345+username@users.noreply.github.com
-        # or: username@users.noreply.github.com
-        local = email.split("@")[0]
-        if "+" in local:
-            return local.split("+", 1)[1]
-        return local
-
-    # gh api handles URL encoding; pass email directly in the query
-    output = run_cmd([
-        "gh", "api", f"search/users?q={email}+in:email",
-        "--jq", ".items[0].login",
-    ])
-    return output if output else None
-
-
-def get_current_github_user() -> str | None:
-    """Get the currently authenticated GitHub username."""
-    output = run_cmd(["gh", "api", "/user", "--jq", ".login"])
-    return output if output else None
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Find top git contributors for PR reviewer assignment"
-    )
-    parser.add_argument("file_path", help="Path to the file to find reviewers for")
-    parser.add_argument(
-        "--count", type=int, default=2,
-        help="Number of reviewers to find (default: 2)",
-    )
-    args = parser.parse_args()
-
-    current_user = get_current_github_user()
-
-    # Request extra candidates to compensate for self-exclusion
-    fetch_count = args.count + 1 if current_user else args.count
-    emails = get_top_authors(args.file_path, fetch_count)
-    if not emails:
-        print(json.dumps({"reviewers": [], "note": "No recent authors found"}))
-        return
-
-    reviewers: list[str] = []
-    for email in emails:
-        username = email_to_github_username(email)
-        if username and username != current_user:
-            reviewers.append(username)
-
-    print(json.dumps({"reviewers": reviewers[:args.count]}))
-
-
-if __name__ == "__main__":
-    main()

package/skills/warden-sweep/scripts/generate_report.py

@@ -1,266 +0,0 @@
-#!/usr/bin/env python3
-# /// script
-# requires-python = ">=3.9"
-# ///
-"""
-Generate summary.md and report.json from a completed sweep.
-
-Usage:
-    python generate_report.py <sweep-dir>
-
-Reads the data/ subdirectory for all-findings.jsonl, verified.jsonl,
-rejected.jsonl, patches.jsonl, and security/index.jsonl, then produces:
-  - <sweep-dir>/summary.md
-  - <sweep-dir>/data/report.json
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import sys
-from datetime import datetime, timezone
-from typing import Any
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from _utils import read_json, read_jsonl, severity_badge  # noqa: E402
-
-
-def generate_summary_md(
-    manifest: dict[str, Any],
-    scan_index: list[dict[str, Any]],
-    all_findings: list[dict[str, Any]],
-    verified: list[dict[str, Any]],
-    rejected: list[dict[str, Any]],
-    patches: list[dict[str, Any]],
-    security_index: list[dict[str, Any]],
-) -> str:
-    """Generate the summary.md content."""
-    run_id = manifest.get("runId", "unknown")
-    started_at = manifest.get("startedAt", "unknown")
-    repo = manifest.get("repo", "unknown")
-    completed_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-
-    files_scanned = sum(1 for e in scan_index if e.get("status") == "complete")
-    files_timed_out = sum(
-        1 for e in scan_index
-        if e.get("status") == "error" and e.get("error") == "timeout"
-    )
-    files_errored = sum(
-        1 for e in scan_index
-        if e.get("status") == "error" and e.get("error") != "timeout"
-    )
-
-    prs_created = sum(1 for p in patches if p.get("status") == "created")
-    prs_failed = sum(1 for p in patches if p.get("status") == "error")
-
-    # Severity breakdown of verified findings
-    by_severity: dict[str, int] = {}
-    for f in verified:
-        sev = f.get("severity", "info")
-        by_severity[sev] = by_severity.get(sev, 0) + 1
-
-    lines = [
-        f"# Warden Sweep: `{run_id}`",
-        "",
-        f"**Repo**: {repo}",
-        f"**Started**: {started_at}",
-        f"**Completed**: {completed_at}",
-        "",
-        "## Stats",
-        "",
-        f"| Metric | Count |",
-        f"|--------|-------|",
-        f"| Files scanned | {files_scanned} |",
-        f"| Files timed out | {files_timed_out} |",
-        f"| Files errored | {files_errored} |",
-        f"| Total findings | {len(all_findings)} |",
-        f"| Verified | {len(verified)} |",
-        f"| Rejected | {len(rejected)} |",
-        f"| PRs created | {prs_created} |",
-        f"| PRs failed | {prs_failed} |",
-        f"| Security findings | {len(security_index)} |",
-        "",
-    ]
-
-    if by_severity:
-        lines.append("### By Severity")
-        lines.append("")
-        for sev in ["critical", "high", "medium", "low", "info"]:
-            count = by_severity.get(sev, 0)
-            if count > 0:
-                lines.append(f"- {severity_badge(sev)}: {count}")
-        lines.append("")
-
-    # Security callout
-    if security_index:
-        lines.append("## Security Findings")
-        lines.append("")
-        lines.append("The following findings are security-related and may need priority review:")
-        lines.append("")
-        lines.append("| ID | Severity | Skill | File | Title |")
-        lines.append("|----|----------|-------|------|-------|")
-        for sf in security_index:
-            fid = sf.get("findingId", "")
-            sev = severity_badge(sf.get("severity", "info"))
-            skill = sf.get("skill", "")
-            filepath = sf.get("file", "")
-            title = sf.get("title", "")
-            lines.append(f"| `{fid}` | {sev} | {skill} | `{filepath}` | {title} |")
-        lines.append("")
-
-    # Verified findings table
-    if verified:
-        lines.append("## Verified Findings")
-        lines.append("")
-        lines.append("| ID | Severity | Skill | File | Title | PR |")
-        lines.append("|----|----------|-------|------|-------|-----|")
-
-        # Build patches lookup
-        pr_lookup: dict[str, str] = {}
-        for p in patches:
-            if p.get("status") == "created" and p.get("findingId"):
-                pr_lookup[p["findingId"]] = p.get("prUrl", "")
-
-        for f in verified:
-            fid = f.get("findingId", "")
-            sev = severity_badge(f.get("severity", "info"))
-            skill = f.get("skill", "")
-            filepath = f.get("file", "")
-            title = f.get("title", "")
-            pr_url = pr_lookup.get(fid, "")
-            pr_link = f"[PR]({pr_url})" if pr_url else "-"
-            lines.append(f"| `{fid}` | {sev} | {skill} | `{filepath}` | {title} | {pr_link} |")
-        lines.append("")
-
-    # Rejected findings summary
-    if rejected:
-        lines.append(f"## Rejected Findings ({len(rejected)})")
-        lines.append("")
-        lines.append("These findings were evaluated and determined to be false positives.")
-        lines.append("See `data/rejected.jsonl` for details.")
-        lines.append("")
-
-    lines.append("---")
-    lines.append(f"*Generated by Warden Sweep `{run_id}`*")
-
-    return "\n".join(lines) + "\n"
-
-
-def generate_report_json(
-    manifest: dict[str, Any],
-    scan_index: list[dict[str, Any]],
-    all_findings: list[dict[str, Any]],
-    verified: list[dict[str, Any]],
-    rejected: list[dict[str, Any]],
-    patches: list[dict[str, Any]],
-    security_index: list[dict[str, Any]],
-) -> dict[str, Any]:
-    """Generate the report.json data."""
-    run_id = manifest.get("runId", "unknown")
-    completed_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-
-    files_scanned = sum(1 for e in scan_index if e.get("status") == "complete")
-    files_timed_out = sum(
-        1 for e in scan_index
-        if e.get("status") == "error" and e.get("error") == "timeout"
-    )
-    files_errored = sum(
-        1 for e in scan_index
-        if e.get("status") == "error" and e.get("error") != "timeout"
-    )
-    prs_created = sum(1 for p in patches if p.get("status") == "created")
-    prs_failed = sum(1 for p in patches if p.get("status") == "error")
-
-    # Count verify errors (findings in all but not in verified or rejected)
-    verified_ids = {f["findingId"] for f in verified if "findingId" in f}
-    rejected_ids = {f["findingId"] for f in rejected if "findingId" in f}
-    all_ids = {f["findingId"] for f in all_findings if "findingId" in f}
-    verify_errors = len(all_ids - verified_ids - rejected_ids)
-
-    return {
-        "runId": run_id,
-        "completedAt": completed_at,
-        "scan": {
-            "filesScanned": files_scanned,
-            "filesTimedOut": files_timed_out,
-            "filesErrored": files_errored,
-            "totalFindings": len(all_findings),
-        },
-        "verify": {
-            "verified": len(verified),
-            "rejected": len(rejected),
-            "errors": verify_errors,
-        },
-        "patch": {
-            "prsCreated": prs_created,
-            "prsFailed": prs_failed,
-        },
-        "security": {
-            "count": len(security_index),
-        },
-        "prs": [
-            {
-                "findingId": p.get("findingId", ""),
-                "url": p.get("prUrl", ""),
-                "severity": next(
-                    (f.get("severity", "") for f in verified if f.get("findingId") == p.get("findingId")),
-                    "",
-                ),
-            }
-            for p in patches
-            if p.get("status") == "created"
-        ],
-    }
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Generate sweep summary and report"
-    )
-    parser.add_argument("sweep_dir", help="Path to the sweep output directory")
-    args = parser.parse_args()
-
-    sweep_dir = args.sweep_dir
-    data_dir = os.path.join(sweep_dir, "data")
-
-    # Read inputs
-    manifest = read_json(os.path.join(data_dir, "manifest.json")) or {}
-    scan_index = read_jsonl(os.path.join(data_dir, "scan-index.jsonl"))
-    all_findings = read_jsonl(os.path.join(data_dir, "all-findings.jsonl"))
-    verified = read_jsonl(os.path.join(data_dir, "verified.jsonl"))
-    rejected = read_jsonl(os.path.join(data_dir, "rejected.jsonl"))
-    patches = read_jsonl(os.path.join(data_dir, "patches.jsonl"))
-    security_index = read_jsonl(os.path.join(sweep_dir, "security", "index.jsonl"))
-
-    # Generate summary.md
-    summary_md = generate_summary_md(
-        manifest, scan_index,
-        all_findings, verified, rejected, patches, security_index,
-    )
-    summary_path = os.path.join(sweep_dir, "summary.md")
-    with open(summary_path, "w") as f:
-        f.write(summary_md)
-
-    # Generate report.json
-    report = generate_report_json(
-        manifest, scan_index, all_findings,
-        verified, rejected, patches, security_index,
-    )
-    report_path = os.path.join(data_dir, "report.json")
-    with open(report_path, "w") as f:
-        json.dump(report, f, indent=2)
-        f.write("\n")
-
-    print(json.dumps({
-        "summaryPath": summary_path,
-        "reportPath": report_path,
-        "verified": len(verified),
-        "rejected": len(rejected),
-        "prsCreated": report["patch"]["prsCreated"],
-        "securityFindings": len(security_index),
-    }))
-
-
-if __name__ == "__main__":
-    main()