sanityops-cli 0.1.3__py3-none-any.whl

sanityops_cli/constants/exit_codes.py

@@ -0,0 +1,19 @@
+# Copyright 2026 zipsonken
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# Exit codes for sanityops-cli
+EXIT_SUCCESS = 0
+EXIT_DEFECTS_FOUND = 1
+EXIT_FAILURE = 2

sanityops_cli/defect_checker/__init__.py

@@ -0,0 +1,16 @@
+# Copyright 2026 zipsonken
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""Defect checking for extracted artifacts via the defect-check SDK."""

sanityops_cli/defect_checker/checker.py

@@ -0,0 +1,100 @@
+# Copyright 2026 zipsonken
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""Convert FindingsResult into defect-check SDK input and invoke the SDK."""
+
+from __future__ import annotations
+
+import defect_check
+from defect_check.models import DefectCheckOptions
+
+from sanityops_cli.agents.scanner_agent.models.finding import (
+    Finding,
+    FindingsResult,
+    FindingType,
+)
+
+
+class DefectChecker:
+    """Checks extracted artifacts for defects using the defect-check SDK."""
+
+    def __init__(self, llm_config: dict[str, str]):
+        """Initialize with the resolved LLM config.
+
+        Args:
+            llm_config: dict with keys llm_provider, llm_api_key,
+                llm_model_id, llm_base_url.
+        """
+        self.llm_config = llm_config
+
+    async def check(
+        self,
+        findings: FindingsResult,
+        check_level: str = "L2",
+    ) -> dict:
+        """Run defect check and return the raw SDK response dict."""
+        tools = self._convert_tools(findings.tools)
+        prompts = self._convert_prompts(findings.prompts)
+        skills = self._convert_skills(findings.skills)
+        options = DefectCheckOptions(
+            enable_cross_check=True,
+        )
+
+        return await defect_check.check(
+            tools=tools,
+            prompts=prompts,
+            skills=skills,
+            check_level=check_level,
+            llm_provider=self.llm_config.get("llm_provider"),
+            llm_api_key=self.llm_config.get("llm_api_key"),
+            llm_model_id=self.llm_config.get("llm_model_id"),
+            llm_base_url=self.llm_config.get("llm_base_url"),
+            options=options
+        )
+
+    def _convert_tools(self, tools: list[Finding]) -> list[dict]:
+        result: list[dict] = []
+        for finding in tools:
+            content = finding.content
+            if content is None or finding.type != FindingType.TOOL:
+                continue
+            result.append({
+                "name": content.name,
+                "description": content.description,
+                "parameters": content.parameters,
+            })
+        return result
+
+    def _convert_prompts(self, prompts: list[Finding]) -> list[dict]:
+        result: list[dict] = []
+        for finding in prompts:
+            content = finding.content
+            if content is None or finding.type != FindingType.PROMPT:
+                continue
+            result.append({"content": content.content})
+        return result
+
+    def _convert_skills(self, skills: list[Finding]) -> list[dict]:
+        result: list[dict] = []
+        for finding in skills:
+            content = finding.content
+            if content is None or finding.type != FindingType.SKILL:
+                continue
+            result.append({
+                "id": finding.relative,
+                "name": content.name,
+                "content": content.to_markdown(),
+            })
+        return result

sanityops_cli/defect_checker/llm_config.py

@@ -0,0 +1,112 @@
+# Copyright 2026 zipsonken
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""Auto-detect LLM configuration for the defect-check SDK."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+
+# Workaround: sanityops-agent 0.0.2 installs modules flat in site-packages root
+# instead of under sanityops_agent/. Import from flat location.
+try:
+    from sanityops_agent.config import ProviderConfig
+except ModuleNotFoundError:
+    from config import ProviderConfig  # type: ignore[import-untyped]
+
+# Default config file location
+DEFAULT_CONFIG_DIR = ".sanityops"
+DEFAULT_CONFIG_FILE = "inspect_config.yaml"
+
+
+def _read_model_section(config_path: str | None) -> dict[str, str]:
+    """Read model section from config file if present.
+
+    Args:
+        config_path: Path to config file, or None to use default location.
+
+    Returns:
+        Dict with keys llm_provider, llm_api_key, llm_model_id, llm_base_url
+        if model section is present and valid. Empty dict {} if model section
+        absent or file missing/unreadable.
+    """
+    # Resolve config file path
+    if config_path:
+        p = Path(config_path).expanduser()
+    else:
+        p = Path.cwd() / DEFAULT_CONFIG_DIR / DEFAULT_CONFIG_FILE
+
+    # If file doesn't exist, return empty (fall back to env vars)
+    if not p.exists() or not p.is_file():
+        return {}
+
+    # Try to read and parse YAML
+    try:
+        with open(p, encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+    except (yaml.YAMLError, OSError):
+        return {}
+
+    if not isinstance(data, dict):
+        return {}
+
+    model = data.get("model")
+    if not isinstance(model, dict):
+        return {}
+
+    # Check for required fields - if any missing, fall back to env vars
+    provider = model.get("provider")
+    api_key = model.get("api_key")
+    model_id = model.get("model_id")
+
+    if not provider or not api_key or not model_id:
+        return {}
+
+    # All required fields present and non-empty
+    return {
+        "llm_provider": str(provider),
+        "llm_api_key": str(api_key),
+        "llm_model_id": str(model_id),
+        "llm_base_url": str(model.get("base_url", "")),
+    }
+
+
+def resolve_llm_config(config_path: str | None = None) -> dict[str, str]:
+    """Resolve the four LLM params accepted by defect_check.check().
+
+    Precedence: config file `model:` section -> ProviderConfig (env vars).
+
+    Args:
+        config_path: Optional path to config file. If None, looks for
+            .sanityops/inspect_config.yaml in current working directory.
+
+    Returns:
+        dict with keys: llm_provider, llm_api_key, llm_model_id, llm_base_url
+    """
+    # Try config file first
+    config_values = _read_model_section(config_path)
+    if config_values:
+        return config_values
+
+    # Fall back to ProviderConfig (env vars)
+    config = ProviderConfig()
+    return {
+        "llm_provider": config.LLM_PROVIDER,
+        "llm_api_key": config.API_KEY,
+        "llm_model_id": config.MODEL_ID,
+        "llm_base_url": config.BASE_URL or "",
+    }

sanityops_cli/defect_checker/markdown_reporter.py

@@ -0,0 +1,249 @@
+# Copyright 2026 zipsonken
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+"""Generate and persist a full Markdown report from a defect-check response dict."""
+
+from __future__ import annotations
+
+import html
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from sanityops_cli.defect_checker.renderer import _MODULE_LABELS
+
+_log = logging.getLogger(__name__)
+
+
+def _esc_md_cell(text: str | None) -> str:
+    """Escape markdown table cell content: pipes and newlines."""
+    if text is None:
+        return "—"
+    text = html.escape(str(text))
+    # Replace pipe to avoid breaking table columns
+    text = text.replace("|", r"\|")
+    # Replace newlines with <br> so multi-line content stays in one cell
+    text = text.replace("\n", "<br>")
+    # Strip leading/trailing whitespace to keep table compact
+    return text.strip()
+
+
+def _format_score(score: dict[str, Any] | None) -> str:
+    """Format score/grade/gate for a section header, or empty string."""
+    if score is None:
+        return ""
+    parts = []
+    if "total_score" in score:
+        max_score = score.get("max_score", 100.0)
+        parts.append(f"score {score['total_score']}/{max_score}")
+    if score.get("grade"):
+        parts.append(f"grade {score['grade']}")
+    if score.get("gate_result"):
+        parts.append(f"gate {score['gate_result']}")
+    return ", ".join(parts)
+
+
+def _aggregate_cross_defects(cross_results: list[dict]) -> list[dict]:
+    """Aggregate defects from all CROSS sub-results (PS/PT/ST) into one list.
+
+    Maps SDK DefectItem format to CrossScoringCalculator format:
+        id -> defect_id
+        severity -> defect_level
+        category -> relation (QD-PS, QD-PT, QD-ST)
+    """
+    defects = []
+    for result in cross_results:
+        for d in result.get("defects") or []:
+            if not isinstance(d, dict):
+                continue
+            defects.append({
+                "defect_id": d.get("id"),
+                "defect_level": d.get("severity"),
+                "relation": d.get("category"),
+            })
+    return defects
+
+
+def _calculate_cross_score(
+    defects: list[dict],
+    check_level: str,
+) -> dict | None:
+    """Compute merged CROSS score using SDK's CrossScoringCalculator.
+
+    The SDK uses weighted deductions per PS/PT/ST group:
+        P0:P1:P2 = 5:3:1 deduction weights
+        Gate FAIL when any group has P0 defect
+
+    Returns None on any failure so the report degrades gracefully instead of
+    crashing. This is intentional: the SDK import or calculation may fail in
+    unexpected ways, and we prefer an unscored CROSS section over no report.
+    """
+    if not defects:
+        return None
+    try:
+        from defect_check.cross.scoring import CrossScoringCalculator
+        scoring = CrossScoringCalculator().calculate_score(defects, check_level, mode=None)
+    except Exception as e:
+        # Intentional broad catch: SDK import, configuration, or calculation
+        # failures should not prevent report generation.
+        _log.warning("Cross scoring calculation failed: %s", e)
+        return None
+    return {
+        "total_score": scoring.get("total_score"),
+        "gate_result": scoring.get("gate_result", "PASS"),
+    }
+
+
+def _build_report(
+    response: dict[str, Any],
+    *,
+    project_id: str | None,
+    check_level: str,
+    generated_at: datetime,
+) -> str:
+    """Render the full markdown report body."""
+    summary = response.get("summary", {})
+    results = response.get("results", [])
+    errors = response.get("errors", [])
+    metadata = response.get("metadata", {})
+    status = response.get("status", "unknown")
+
+    lines: list[str] = []
+    lines.append("# Inspect Report")
+    lines.append("")
+
+    # Meta
+    lines.append(f"- **Generated**: {generated_at.strftime('%Y-%m-%d %H:%M:%S')}")
+    lines.append(f"- **Check level**: {check_level}")
+    lines.append(f"- **Status**: {status}")
+    if project_id:
+        lines.append(f"- **Project ID**: {project_id}")
+    exec_time = metadata.get("execution_time_seconds")
+    if exec_time is not None:
+        lines.append(f"- **Execution time**: {exec_time:.2f}s")
+    lines.append("")
+
+    # Summary
+    lines.append("## Summary")
+    lines.append("")
+    lines.append("| Metric | Value |")
+    lines.append("|---|---|")
+    total = summary.get("total_defects", 0)
+    p0 = summary.get("p0_count", 0)
+    p1 = summary.get("p1_count", 0)
+    p2 = summary.get("p2_count", 0)
+    gate = summary.get("gate_result", "PASS")
+    lines.append(f"| Total defects | {total} |")
+    lines.append(f"| Severity | P0: {p0} / P1: {p1} / P2: {p2} |")
+    lines.append(f"| Gate | {gate} |")
+    lines.append("")
+
+    # Separate CROSS from other modules and merge
+    module_results = [r for r in results if r.get("module") != "CROSS"]
+    cross_results = [r for r in results if r.get("module") == "CROSS"]
+
+    if cross_results:
+        # Merge all CROSS sub-results into single section
+        cross_defects = [d for r in cross_results for d in (r.get("defects") or [])]
+        mapped_defects = _aggregate_cross_defects(cross_results)
+        cross_score = _calculate_cross_score(mapped_defects, check_level)
+
+        module_results.append({
+            "module": "CROSS",
+            "status": "completed",
+            "defects": cross_defects,
+            "score": cross_score,
+        })
+
+    # Per-module results
+    for result in module_results:
+        module = result.get("module", "")
+        label = _MODULE_LABELS.get(module, module)
+        result_status = result.get("status", "unknown")
+        score = result.get("score")
+        defects = result.get("defects", [])
+
+        score_str = _format_score(score)
+        header = f"## {label} ({module}) — {result_status}"
+        if score_str:
+            header += f", {score_str}"
+        lines.append(header)
+        lines.append("")
+
+        if not defects:
+            lines.append("No defects found.")
+            lines.append("")
+            continue
+
+        lines.append("| ID | Name | Severity | Description | Location | Impact | Fix |")
+        lines.append("|---|---|---|---|---|---|---|")
+        for defect in defects:
+            defect_id = _esc_md_cell(defect.get("id"))
+            name = _esc_md_cell(defect.get("name"))
+            severity = _esc_md_cell(defect.get("severity"))
+            description = _esc_md_cell(defect.get("description"))
+            location = _esc_md_cell(defect.get("location"))
+            impact = _esc_md_cell(defect.get("impact"))
+            fix = _esc_md_cell(defect.get("fix_suggestion"))
+            lines.append(
+                f"| {defect_id} | {name} | {severity} | {description} |"
+                f" {location} | {impact} | {fix} |"
+            )
+        lines.append("")
+
+    # Errors section
+    if errors:
+        lines.append("## Errors")
+        lines.append("")
+        for err in errors:
+            code = err.get("code", "unknown")
+            message = err.get("message", "")
+            retryable = err.get("retryable", False)
+            lines.append(f"- **{code}** (retryable={retryable}): {message}")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def save_markdown_report(
+    response: dict[str, Any],
+    output_dir: Path,
+    *,
+    project_id: str | None = None,
+    check_level: str = "L2",
+) -> Path:
+    """Persist a full markdown report and return the written file path.
+
+    Args:
+        response: Raw dict returned by defect_check.check().
+        output_dir: Directory where the report will be written.
+        project_id: Optional project identifier to include in the report.
+        check_level: Inspection level (L1/L2/L3) to include in the report.
+
+    Returns:
+        Path to the written markdown file.
+    """
+    output_dir = output_dir.expanduser().resolve()
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    generated_at = datetime.now()
+    filename = f"inspect-{generated_at.strftime('%Y%m%d-%H%M%S-%f')}.md"
+    path = output_dir / filename
+
+    body = _build_report(response, project_id=project_id, check_level=check_level, generated_at=generated_at)
+    path.write_text(body, encoding="utf-8")
+
+    return path