sanityops-cli 0.1.3__py3-none-any.whl

sanityops_cli/__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.
+#
+
+__version__ = "0.1.3"

sanityops_cli/agents/__init__.py

@@ -0,0 +1,14 @@
+# 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.
+#

sanityops_cli/agents/repair_agent/__init__.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.
+
+"""Repair agent for generating fixed artifact content from inspection reports."""
+
+from .agent import RepairAgent
+
+__all__ = ["RepairAgent"]

sanityops_cli/agents/repair_agent/agent.py

@@ -0,0 +1,230 @@
+# 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.
+
+"""Repair agent: generate repaired artifact content from a local defect report."""
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import anyio
+from rich.console import Console
+
+from sanityops_cli.exceptions.base_exceptions import ValidationError
+
+if TYPE_CHECKING:
+    from sanityops_cli.logging.logger import Logger
+
+# ============================================================================
+# RepairAgent Class
+# ============================================================================
+
+
+class RepairAgent:
+    """Runs an LLM agent that rewrites defective artifacts using the report.
+
+    Mirrors ScannerAgent: builds a sanityops_agent parent agent with a tool
+    registry (read + store_repair), feeds it the inspection report plus the
+    artifact paths, and collects repairs via the shared-memory
+    StoreRepairsTool.
+    """
+
+    def __init__(
+        self,
+        provider,
+        max_loops: int = 30,
+        timeout: int = 300,
+        token_budget: int | None = None,
+        llm_retries: int = 3,
+        retry_delay: float = 65.0,
+        verbose: bool = False,
+        console: Console | None = None,
+        logger: "Logger | None" = None,
+    ):
+        self.provider = provider
+        self.max_loops = max_loops
+        self.timeout = timeout
+        self.token_budget = token_budget
+        self.verbose = verbose
+        self.console = console or Console()
+        self.logger = logger
+        # Rate-limit resilience: the server-side LLM proxy may cap requests
+        # far below what one repair run needs (e.g. rpm_limit=1). The SDK's
+        # own retry backs off only 1-2s, so we retry the whole run here with
+        # a delay long enough to clear a per-minute quota.
+        self.llm_retries = llm_retries
+        self.retry_delay = retry_delay
+
+    async def repair(
+        self,
+        report_path: str,
+        artifacts: dict[str, list[str]],
+        project_root: str,
+    ) -> list[dict]:
+        """Repair artifacts listed in the report.
+
+        Retries the whole run on rate-limit errors (nothing to lose: repairs
+        only materialize after store_repair, and a rate-limited run usually
+        dies before storing anything).
+        """
+        last_error: Exception | None = None
+        for attempt in range(self.llm_retries + 1):
+            try:
+                return await self._run_once(report_path, artifacts, project_root)
+            except ValidationError as e:
+                last_error = e
+                if attempt >= self.llm_retries or not _is_rate_limit_error(e):
+                    raise
+                self.console.print(
+                    f"  [yellow]⚠[/] LLM rate limited — waiting {self.retry_delay:.0f}s "
+                    f"before retry {attempt + 1}/{self.llm_retries}..."
+                )
+                await anyio.sleep(self.retry_delay)
+        assert last_error is not None
+        raise last_error
+
+    async def _run_once(
+        self,
+        report_path: str,
+        artifacts: dict[str, list[str]],
+        project_root: str,
+    ) -> list[dict]:
+        """Single repair attempt (see repair() for the retry wrapper)."""
+        from sanityops_agent.agents import AgentFactory
+        from sanityops_agent.core.agent import AgentConfig, TerminationReason
+        from sanityops_agent.hooks.base import HookExecutor
+        from sanityops_agent.tools import ToolRegistry
+
+        from sanityops_cli.agents.repair_agent.prompts import REPAIR_AGENT_PROMPT
+        from sanityops_cli.agents.repair_agent.tools.store_repairs_tool import StoreRepairsTool
+        from sanityops_cli.agents.scanner_agent.tools.readfile_tool import FileReadTool
+
+        report = Path(report_path).resolve()
+        if not report.is_file():
+            raise ValidationError(f"Report not found: {report_path}")
+
+        all_paths = (
+            artifacts.get("prompts", []) + artifacts.get("tools", []) + artifacts.get("skills", [])
+        )
+        if not all_paths:
+            raise ValidationError("No artifacts configured to repair")
+
+        for p in all_paths:
+            path = Path(p)
+            if not path.is_absolute():
+                raise ValidationError(f"Artifact path must be absolute: {p}")
+            if not path.exists():
+                raise ValidationError(f"Artifact path does not exist: {p}")
+
+        # Deliberately NO TaskTool: repair must follow the artifact list
+        # exactly, not spawn sub-agents to explore the project. Registering it
+        # led agents to wander (listing directories, reading bogus paths) and
+        # burn the whole token budget without storing a single repair.
+        registry = ToolRegistry()
+        registry.register(FileReadTool())
+        registry.register(StoreRepairsTool())
+        StoreRepairsTool.clear()
+
+        artifact_lines: list[str] = []
+        for kind, key in (("prompt", "prompts"), ("tool", "tools"), ("skill", "skills")):
+            for p in artifacts.get(key) or []:
+                artifact_lines.append(f"- type: {kind}, path: {p}")
+
+        system_prompt = REPAIR_AGENT_PROMPT.format(
+            report_path=str(report),
+            project_root=project_root,
+            artifact_list="\n".join(artifact_lines),
+        )
+
+        config_kwargs = {
+            "max_loops": self.max_loops,
+            "total_timeout": self.timeout,
+            "system_prompt": system_prompt,
+        }
+        if self.token_budget:
+            config_kwargs["token_budget"] = self.token_budget
+
+        config = AgentConfig(**config_kwargs)
+
+        hook_executor = HookExecutor()
+        if self.verbose and self.logger:
+            from sanityops_cli.agents.scanner_agent.hooks.progress_hook import ProgressHook
+            hook_executor.register(
+                ProgressHook(self.console, verbose=self.verbose, logger=self.logger)
+            )
+
+        factory = AgentFactory(
+            provider=self.provider,
+            config=config,
+            tool_registry=registry,
+            hook_executor=hook_executor,
+        )
+        agent = factory.create_parent_agent(system_prompt=system_prompt)
+
+        if self.verbose:
+            self.console.print()
+
+        result = await agent.run(f"Repair artifacts listed in report {report}")
+
+        if self.verbose:
+            self.console.print()
+
+        repairs = StoreRepairsTool.get_repairs()
+        if result.termination_reason != TerminationReason.END_TURN:
+            # Any termination after repairs were already stored is a partial
+            # success: return collected repairs with a warning instead of
+            # discarding them (budget/loop exhaustion or a mid-run LLM error).
+            if repairs:
+                if self.verbose:
+                    self.console.print(
+                        f"  [yellow]⚠[/] Agent stopped ({result.termination_reason.value}) "
+                        f"after {len(repairs)} repair(s) were collected"
+                    )
+                return repairs
+            error_msg = result.error or f"Agent terminated: {result.termination_reason.value}"
+            if result.error_detail:
+                error_detail_str = "\n".join(
+                    f"  - {e.error_type}: {e.message}" for e in result.error_detail
+                )
+                error_msg += f"\nError Detail:\n{error_detail_str}"
+            raise ValidationError(f"Agent execution failed: {error_msg}")
+
+        return repairs
+
+    def repair_sync(
+        self,
+        report_path: str,
+        artifacts: dict[str, list[str]],
+        project_root: str,
+    ) -> list[dict]:
+        """Synchronous wrapper around repair()."""
+        return anyio.run(self.repair, report_path, artifacts, project_root)
+
+
+def _is_rate_limit_error(exc: BaseException) -> bool:
+    """Best-effort detection of a server-side rate limit / throttling error.
+
+    The LLM proxy (litellm) surfaces these as 429 with `throttling_error`, or
+    as 5xx wrappers whose message still mentions the rate limit. Matching on
+    the text markers keeps this working across provider SDKs.
+    """
+    text = str(exc).lower()
+    markers = (
+        "429",
+        "rate limit",
+        "ratelimiterror",
+        "throttling_error",
+        "too many requests",
+        "no deployments available",
+    )
+    return any(marker in text for marker in markers)

sanityops_cli/agents/repair_agent/prompts.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.
+
+"""System prompt for the repair agent."""
+
+REPAIR_AGENT_PROMPT = """\
+You are an artifact repair agent. Your job is to fix the defects reported in an
+inspection report by rewriting the defective artifacts.
+
+## Inputs
+
+- `{report_path}`: Absolute path to the inspection report (markdown). It lists
+  every defect found in the artifacts, grouped per artifact, with severity
+  (P0/P1/P2), description, location, impact, and a suggested fix.
+- Artifacts live under the project root `{project_root}`. Paths referenced in
+  the report (or listed below) are relative to it unless absolute.
+
+## Artifacts Under Repair
+
+The following artifacts were inspected and may require repair:
+{artifact_list}
+
+## Workflow (follow strictly)
+
+1. Read the inspection report at `{report_path}` using the `read` tool.
+2. Identify every artifact that has at least one defect in the report.
+   Artifacts whose section says "No defects found" must be skipped entirely.
+3. For each defective artifact, in this order:
+   a. Read the artifact source file with the `read` tool — use the EXACT
+      absolute path from the list above. Never guess, never explore the
+      project, never read paths you have not been given.
+   b. Rewrite the FULL artifact content so that all reported defects in that
+      artifact are resolved. You must not introduce new defects; keep the
+      original structure, language, and unrelated content intact. Apply the
+      report's suggested fixes unless they conflict with other content, in
+      which case use your judgment to keep the artifact consistent.
+   c. Call `store_repair` immediately with:
+      - artifact_type: "prompt" | "tool" | "skill"
+      - artifact_path: absolute path of the artifact file you read
+      - repaired_content: the complete rewritten file content
+      - summary: one short paragraph listing which defect IDs you addressed
+4. Cross-module defects (IDs starting with QD-PT / QD-ST, shown in the
+   "Cross" section) describe inconsistencies BETWEEN artifacts. Resolve them
+   by editing the artifact(s) the fix suggestion targets; a single cross
+   defect may require touching two artifacts — store each repaired artifact
+   separately.
+
+## Output Language
+
+- All summaries and repair descriptions must be written in English.
+- Preserve the original language of the artifact content itself (Chinese stays
+  Chinese, English stays English). Comments and explanations inside the
+  repaired content should be minimal.
+
+## Scope discipline (IMPORTANT)
+
+You have exactly two tools and one job. Do NOT:
+- explore the project tree, list directories, or glob for other files;
+- read the report more than once;
+- read any path that is not in the Artifacts list above (a failed read
+  wastes a full turn and the token budget);
+- rewrite artifacts that have no defects.
+
+Every wasted turn can exhaust the budget before a single repair is stored.
+
+## Rules
+
+- repaired_content MUST be the complete file content, never a diff or snippet.
+- Never delete functionality to make a defect disappear unless the report
+  explicitly says so; prefer completing or correcting definitions.
+- If the report contains no defects at all, store nothing and report that.
+- Process artifacts one at a time: read -> repair -> store_repair -> next.
+- Token budget is limited. Be economical: do NOT re-read files you have
+  already read; do NOT re-store an artifact you already stored (unless you
+  are correcting it); think through the repair BEFORE producing output and
+  emit the repaired content in one shot — avoid iterating on drafts.
+
+## Available Tools
+
+- `read(file_path)`: read a file from disk. `file_path` must be an absolute path.
+- `store_repair(...)`: REQUIRED. Store each repaired artifact exactly as
+  specified above.
+
+## Termination
+
+Finish when every defective artifact has been stored via `store_repair`.
+Then reply with a one-line summary: how many artifacts repaired, how many
+defect IDs addressed.
+"""

sanityops_cli/agents/repair_agent/tools/__init__.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.
+
+"""Repair agent tools."""
+
+from .store_repairs_tool import StoreRepairsTool
+
+__all__ = ["StoreRepairsTool"]

sanityops_cli/agents/repair_agent/tools/store_repairs_tool.py

@@ -0,0 +1,144 @@
+# 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.
+
+"""Shared-memory store for repaired artifacts produced by the repair agent.
+
+The agent calls `store_repair` once per defective artifact with the fully
+rewritten content; the CLI flushes everything into a single markdown
+report under `.sanityops/repairs/`.
+"""
+
+import json
+from pathlib import Path
+from typing import ClassVar
+
+from sanityops_agent.tools.base import Tool, ToolResult
+
+
+class StoreRepairsTool(Tool):
+    """Shared-memory store for repaired artifacts produced by the repair agent.
+
+    The agent calls `store_repair` once per defective artifact with the fully
+    rewritten content; the CLI flushes everything into a single markdown
+    report under `.sanityops/repairs/`.
+    """
+
+    name = "store_repair"
+    description = "store the repaired content of one artifact"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "artifact_type": {
+                "type": "string",
+                "enum": ["skill", "tool", "prompt"],
+                "description": "which kind of artifact was repaired",
+            },
+            "artifact_path": {
+                "type": "string",
+                "description": "absolute path of the source artifact file that was repaired",
+            },
+            "repaired_content": {
+                "type": "string",
+                "description": "the complete repaired artifact content (full file, not a diff)",
+            },
+            "summary": {
+                "type": "string",
+                "description": "one-paragraph summary of the defects addressed",
+            },
+        },
+        "required": ["artifact_type", "artifact_path", "repaired_content", "summary"],
+    }
+    tags = ["memory", "repair"]
+
+    _repairs: ClassVar[list[dict]] = []
+
+    async def execute(
+        self,
+        artifact_type: str,
+        artifact_path: str,
+        repaired_content: str,
+        summary: str,
+    ) -> ToolResult:
+        """Execute the store_repair operation."""
+        return self._add_repair(artifact_type, artifact_path, repaired_content, summary)
+
+    def _add_repair(
+        self,
+        artifact_type: str,
+        artifact_path: str,
+        repaired_content: str,
+        summary: str,
+    ) -> ToolResult:
+        """Add a repair entry to the shared store."""
+        # Validate artifact_type
+        if artifact_type not in ("skill", "tool", "prompt"):
+            return ToolResult(
+                content="",
+                success=False,
+                error=f"invalid artifact_type: {artifact_type}",
+            )
+
+        # Validate absolute path
+        path = Path(artifact_path)
+        if not path.is_absolute():
+            return ToolResult(
+                content="",
+                success=False,
+                error=f"artifact_path must be absolute: {artifact_path}",
+            )
+
+        # Validate non-empty content
+        if not repaired_content or not repaired_content.strip():
+            return ToolResult(
+                content="",
+                success=False,
+                error="repaired_content is empty",
+            )
+
+        # Create entry
+        entry = {
+            "artifact_type": artifact_type,
+            "artifact_path": str(path),
+            "repaired_content": repaired_content,
+            "summary": summary,
+        }
+
+        # Update existing entry for same artifact, or add new
+        for index, existing in enumerate(self._repairs):
+            if existing["artifact_path"] == entry["artifact_path"]:
+                self._repairs[index] = entry
+                action = "updated"
+                break
+        else:
+            self._repairs.append(entry)
+            action = "added"
+
+        return ToolResult(
+            content=json.dumps({
+                "success": True,
+                "message": f"{action} repair for {artifact_type}: {path.name}",
+                "count": len(self._repairs),
+            }),
+            success=True,
+        )
+
+    @classmethod
+    def get_repairs(cls) -> list[dict]:
+        """Return all stored repairs."""
+        return list(cls._repairs)
+
+    @classmethod
+    def clear(cls) -> None:
+        """Clear all stored repairs."""
+        cls._repairs.clear()