monkeyscode 1.0.0__py3-none-any.whl

monkeyscode/ci.py

@@ -0,0 +1,288 @@
+"""
+MonkeysCode SDK — CI/CD Helpers.
+
+Utilities for running MonkeysCode in CI pipelines:
+- Headless runs with structured output
+- SARIF report generation for GitHub Code Scanning
+- GitHub Actions annotations
+"""
+
+from __future__ import annotations
+
+import re
+import time
+from dataclasses import dataclass, field
+from typing import Any
+
+from monkeyscode.agent import MonkeysCode
+from monkeyscode.events import AgentEvent, AgentResult, CompleteEvent, ErrorEvent, TextEvent
+
+
+@dataclass
+class CiFinding:
+    """A single finding/issue reported by the agent."""
+
+    severity: str  # 'error', 'warning', 'note', 'high', 'medium', 'low'
+    message: str
+    file: str | None = None
+    line: int | None = None
+    end_line: int | None = None
+    column: int | None = None
+    rule_id: str | None = None
+    category: str | None = None
+
+
+@dataclass
+class CiResult:
+    """Result from a CI run."""
+
+    success: bool
+    exit_code: int
+    result: AgentResult
+    findings: list[CiFinding] = field(default_factory=list)
+    events: list[AgentEvent] = field(default_factory=list)
+    duration_ms: int = 0
+
+
+# Exit codes
+CI_EXIT_SUCCESS = 0
+CI_EXIT_ERROR = 1
+CI_EXIT_FINDINGS = 10
+CI_EXIT_HIGH_SEVERITY = 11
+
+
+async def ci_run(
+    *,
+    prompt: str,
+    api_key: str | None = None,
+    model: str = "auto",
+    working_directory: str | None = None,
+    diff: str | None = None,
+    timeout: int = 600_000,
+    on_event: Any = None,
+) -> CiResult:
+    """
+    Run the agent in headless CI mode.
+
+    Args:
+        prompt: The instruction for the agent.
+        api_key: API key.
+        model: Model to use.
+        working_directory: Working directory.
+        diff: Git diff content to provide as context.
+        timeout: Timeout in ms.
+        on_event: Optional callback for streaming events.
+
+    Returns:
+        CiResult with findings, exit code, and events.
+    """
+    start_time = time.monotonic()
+    events: list[AgentEvent] = []
+
+    agent = MonkeysCode(
+        api_key=api_key,
+        model=model,
+        working_directory=working_directory,
+        timeout=timeout,
+        permissions_mode="autoApprove",
+    )
+
+    # Build prompt with diff context
+    full_prompt = prompt
+    if diff:
+        full_prompt = f"{prompt}\n\nHere is the diff to review:\n```diff\n{diff}\n```"
+
+    async for event in agent.stream(full_prompt):
+        events.append(event)
+        if on_event:
+            on_event(event)
+
+    # Build result
+    result = AgentResult(success=False, summary="Agent failed", model=model)
+    for event in events:
+        if isinstance(event, CompleteEvent):
+            result = AgentResult(
+                success=True,
+                summary=event.summary,
+                files_changed=event.files_changed,
+                tokens=event.tokens,
+                cost=event.cost,
+                duration_ms=event.duration_ms,
+                model=model,
+            )
+            break
+        if isinstance(event, ErrorEvent):
+            result = AgentResult(
+                success=False,
+                summary=event.message,
+                exit_code=1,
+                model=model,
+            )
+
+    # Extract findings
+    findings = _extract_findings(events)
+
+    # Determine exit code
+    exit_code = CI_EXIT_SUCCESS
+    if not result.success:
+        exit_code = CI_EXIT_ERROR
+    elif any(f.severity in ("high", "error") for f in findings):
+        exit_code = CI_EXIT_HIGH_SEVERITY
+    elif findings:
+        exit_code = CI_EXIT_FINDINGS
+
+    duration_ms = int((time.monotonic() - start_time) * 1000)
+
+    return CiResult(
+        success=result.success,
+        exit_code=exit_code,
+        result=result,
+        findings=findings,
+        events=events,
+        duration_ms=duration_ms,
+    )
+
+
+def to_sarif(result: CiResult) -> dict[str, Any]:
+    """Convert a CI result to SARIF 2.1.0 format."""
+    rules: dict[str, dict[str, Any]] = {}
+    sarif_results: list[dict[str, Any]] = []
+
+    for finding in result.findings:
+        rule_id = finding.rule_id or finding.category or "monkeyscode-review"
+
+        if rule_id not in rules:
+            rules[rule_id] = {
+                "id": rule_id,
+                "shortDescription": {"text": finding.category or rule_id},
+                "defaultConfiguration": {"level": _map_severity(finding.severity)},
+            }
+
+        sarif_result: dict[str, Any] = {
+            "ruleId": rule_id,
+            "message": {"text": finding.message},
+            "level": _map_severity(finding.severity),
+            "locations": [],
+        }
+
+        if finding.file:
+            location: dict[str, Any] = {
+                "physicalLocation": {
+                    "artifactLocation": {"uri": finding.file},
+                },
+            }
+            if finding.line:
+                location["physicalLocation"]["region"] = {
+                    "startLine": finding.line,
+                }
+                if finding.end_line:
+                    location["physicalLocation"]["region"]["endLine"] = finding.end_line
+            sarif_result["locations"].append(location)
+
+        sarif_results.append(sarif_result)
+
+    return {
+        "$schema": "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json",
+        "version": "2.1.0",
+        "runs": [
+            {
+                "tool": {
+                    "driver": {
+                        "name": "MonkeysCode",
+                        "version": "2.0.0",
+                        "informationUri": "https://monkeyscode.com",
+                        "rules": list(rules.values()),
+                    },
+                },
+                "results": sarif_results,
+            },
+        ],
+    }
+
+
+def print_github_annotations(findings: list[CiFinding]) -> None:
+    """Print GitHub Actions annotations for inline PR display."""
+    for finding in findings:
+        level = "error" if finding.severity in ("high", "error") else "warning"
+        file_part = f"file={finding.file}," if finding.file else ""
+        line_part = f"line={finding.line}," if finding.line else ""
+        title = finding.rule_id or "MonkeysCode Review"
+        print(f"::{level} {file_part}{line_part}title={title}::{finding.message}")
+
+
+def print_ci_summary(result: CiResult) -> None:
+    """Print a human-readable CI summary."""
+    findings = result.findings
+    errors = sum(1 for f in findings if f.severity in ("high", "error"))
+    warnings = sum(1 for f in findings if f.severity in ("medium", "warning"))
+    notes = sum(1 for f in findings if f.severity in ("low", "note"))
+
+    print()
+    print("MonkeysCode CI Review")
+    print(f"  Duration:  {result.duration_ms / 1000:.1f}s")
+    print(f"  Findings:  {len(findings)} total")
+    if errors:
+        print(f"    Errors:    {errors}")
+    if warnings:
+        print(f"    Warnings:  {warnings}")
+    if notes:
+        print(f"    Notes:     {notes}")
+    print(f"  Exit code: {result.exit_code}")
+    print()
+
+
+# ── Private ──────────────────────────────────────────────────────────
+
+
+def _extract_findings(events: list[AgentEvent]) -> list[CiFinding]:
+    """Extract findings from agent events."""
+    findings: list[CiFinding] = []
+
+    for event in events:
+        if not isinstance(event, TextEvent):
+            continue
+
+        for line in event.content.split("\n"):
+            # BUG/ERROR/VULNERABILITY patterns
+            bug_match = re.match(
+                r"(?:BUG|ERROR|CRITICAL|VULNERABILITY):\s*(.+)", line, re.IGNORECASE,
+            )
+            if bug_match:
+                findings.append(
+                    CiFinding(severity="high", message=bug_match.group(1).strip(), category="bug"),
+                )
+
+            # WARNING patterns
+            warn_match = re.match(r"(?:WARNING|WARN|ISSUE):\s*(.+)", line, re.IGNORECASE)
+            if warn_match:
+                findings.append(
+                    CiFinding(
+                        severity="warning", message=warn_match.group(1).strip(), category="warning",
+                    ),
+                )
+
+            # File:line patterns
+            file_match = re.match(r"([^\s:]+\.[a-z]+):(\d+):\s*(.+)", line, re.IGNORECASE)
+            if file_match:
+                findings.append(
+                    CiFinding(
+                        severity="warning",
+                        file=file_match.group(1),
+                        line=int(file_match.group(2)),
+                        message=file_match.group(3).strip(),
+                    ),
+                )
+
+    return findings
+
+
+def _map_severity(severity: str) -> str:
+    """Map severity to SARIF level."""
+    return {
+        "error": "error",
+        "high": "error",
+        "warning": "warning",
+        "medium": "warning",
+        "note": "note",
+        "low": "note",
+    }.get(severity, "warning")