sanityops-cli 0.1.3__py3-none-any.whl

sanityops_cli/utils/artifact_packer.py

@@ -0,0 +1,407 @@
+# 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.
+#
+
+"""Artifact packer — prepare artifacts for upload.
+
+This module handles:
+- Merging multiple prompt files into a single text
+- Merging multiple tool schema files into a JSON array
+- Packing skill directories/files into a ZIP archive
+- Packing from ScannerAgent findings (extracted content)
+"""
+
+from __future__ import annotations
+
+import json
+import warnings
+import zipfile
+from io import BytesIO
+from pathlib import Path
+from typing import Any
+
+from sanityops_cli.agents.scanner_agent.models.finding import (
+    Finding,
+    PromptContent,
+    SkillContent,
+    ToolContent,
+)
+
+# Module-level exclusion set for files/dirs skipped when packing skill directories.
+EXCLUDED_DIRS = {"__pycache__", "node_modules", ".git"}
+
+
+def _is_excluded_path(file_path: Path) -> bool:
+    """Return True if any path component is an excluded directory.
+
+    Compares directory names (not just the final filename), so paths like
+    ``project/__pycache__/module.pyc`` are correctly skipped even though
+    ``file_path.name`` is ``module.pyc``.
+    """
+    return any(part in EXCLUDED_DIRS for part in file_path.parts)
+
+
+class ArtifactPacker:
+    """Prepare artifacts for upload to the sanityops server.
+
+    The server expects:
+    - prompt_content: Single text string (merged from all prompt files)
+    - tools_schema: JSON string of tool definitions array
+    - skill_file: ZIP file containing skill directories/files
+    """
+
+    def __init__(
+        self,
+        prompts: list[str],
+        tools: list[str],
+        skills: list[str],
+    ):
+        """Initialize the packer with artifact file paths.
+
+        Args:
+            prompts: List of absolute paths to prompt files.
+            tools: List of absolute paths to tool schema files.
+            skills: List of absolute paths to skill files or directories.
+        """
+        self.prompts = prompts
+        self.tools = tools
+        self.skills = skills
+
+    def pack(self) -> dict[str, Any]:
+        """Pack all artifacts into upload format.
+
+        Returns:
+            Dict with keys:
+                - prompt_content: str or None
+                - tools_schema: str (JSON) or None
+                - skill_file: tuple(filename, bytes) or None
+
+        Raises:
+            OSError: If files cannot be read.
+            ValueError: If tools schema is invalid JSON.
+        """
+        result: dict[str, Any] = {}
+
+        # Pack prompts
+        result["prompt_content"] = self._pack_prompts()
+
+        # Pack tools
+        result["tools_schema"] = self._pack_tools()
+
+        # Pack skills
+        result["skill_file"] = self._pack_skills()
+
+        return result
+
+    def _pack_prompts(self) -> str | None:
+        """Merge all prompt files into a single text.
+
+        Each file's content is separated by a marker comment.
+
+        Returns:
+            Merged prompt text, or None if no prompts.
+        """
+        if not self.prompts:
+            return None
+
+        parts: list[str] = []
+        for path_str in self.prompts:
+            path = Path(path_str)
+            content = path.read_text(encoding="utf-8")
+
+            # Add a header comment to identify the source file
+            filename = path.name
+            parts.append(f"<!-- BEGIN: {filename} -->")
+            parts.append(content.strip())
+            parts.append(f"<!-- END: {filename} -->")
+            parts.append("")  # Empty line between files
+
+        return "\n".join(parts).strip() if parts else None
+
+    def _pack_tools(self) -> str | None:
+        """Merge all tool schema files into a JSON array.
+
+        Handles both:
+        - Single tool definition objects
+        - Arrays of tool definitions
+
+        Tools are deduplicated by 'name' field.
+
+        Returns:
+            JSON string of tools array, or None if no tools.
+
+        Raises:
+            ValueError: If a tool file contains invalid JSON.
+            ValueError: If tool definitions conflict on name.
+        """
+        if not self.tools:
+            return None
+
+        all_tools: dict[str, dict[str, Any]] = {}  # name -> definition
+
+        for path_str in self.tools:
+            path = Path(path_str)
+            content = path.read_text(encoding="utf-8")
+
+            try:
+                data = json.loads(content)
+            except json.JSONDecodeError as e:
+                raise ValueError(f"Invalid JSON in tool file {path}: {e}") from e
+
+            # Handle both single object and array
+            if isinstance(data, dict):
+                tools_list = [data]
+            elif isinstance(data, list):
+                tools_list = data
+            else:
+                raise ValueError(f"Tool file {path} must contain an object or array")
+
+            # Deduplicate by name
+            for tool_def in tools_list:
+                if not isinstance(tool_def, dict):
+                    continue
+                name = tool_def.get("name")
+                if not name:
+                    continue
+
+                all_tools[name] = tool_def
+
+        if not all_tools:
+            return None
+
+        return json.dumps(list(all_tools.values()), ensure_ascii=False)
+
+    def _pack_skills(self) -> tuple[str, bytes] | None:
+        """Pack skill directories/files into a ZIP archive.
+
+        The ZIP preserves the directory structure relative to the skill root.
+        If multiple skills are provided, they're all packed into one ZIP.
+
+        Returns:
+            Tuple of (filename, bytes) for the ZIP, or None if no skills.
+        """
+        if not self.skills:
+            return None
+
+        buffer = BytesIO()
+
+        with zipfile.ZipFile(buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+            for skill_path_str in self.skills:
+                skill_path = Path(skill_path_str)
+
+                if skill_path.is_file():
+                    # Single skill file
+                    self._add_file_to_zip(zf, skill_path, skill_path.name)
+
+                elif skill_path.is_dir():
+                    # Skill directory - add all files recursively
+                    for file_path in skill_path.rglob("*"):
+                        if file_path.is_file():
+                            # Skip hidden files and excluded directories
+                            if any(part.startswith(".") for part in file_path.parts):
+                                continue
+                            if _is_excluded_path(file_path):
+                                continue
+
+                            # Preserve relative path from skill directory
+                            rel_path = file_path.relative_to(skill_path)
+                            self._add_file_to_zip(zf, file_path, str(rel_path))
+
+        # Return ZIP with a descriptive name
+        return ("skills.zip", buffer.getvalue())
+
+    def _add_file_to_zip(self, zf: zipfile.ZipFile, file_path: Path, archive_name: str) -> None:
+        """Add a file to the ZIP archive.
+
+        Args:
+            zf: ZipFile object.
+            file_path: Path to the file on disk.
+            archive_name: Name/path to use in the ZIP archive.
+        """
+        # Read file content
+        try:
+            content = file_path.read_bytes()
+            zf.writestr(archive_name, content)
+        except OSError as e:
+            warnings.warn(f"Could not read file for ZIP archive: {file_path}: {e}", stacklevel=2)
+
+
+def pack_from_findings(
+    skills: list[Finding],
+    tools: list[Finding],
+    prompts: list[Finding],
+) -> dict[str, Any]:
+    """Pack artifacts from ScannerAgent findings (extracted content).
+
+    This function uses the content already extracted by ScannerAgent,
+    avoiding redundant file reads. It supports:
+    - Prompts extracted from YAML/Python files (e.g., system_prompt field)
+    - Tools extracted from code or schema files
+    - Skills from directories or SKILL.md files
+
+    Args:
+        skills: List of skill findings from ScannerAgent.
+        tools: List of tool findings from ScannerAgent.
+        prompts: List of prompt findings from ScannerAgent.
+
+    Returns:
+        Dict with keys:
+            - prompt_content: str or None
+            - tools_schema: str (JSON) or None
+            - skill_file: tuple(filename, bytes) or None
+    """
+    result: dict[str, Any] = {}
+
+    # Pack prompts from findings
+    result["prompt_content"] = _pack_prompts_from_findings(prompts)
+
+    # Pack tools from findings
+    result["tools_schema"] = _pack_tools_from_findings(tools)
+
+    # Pack skills from findings
+    result["skill_file"] = _pack_skills_from_findings(skills)
+
+    return result
+
+
+def _pack_prompts_from_findings(prompts: list[Finding]) -> str | None:
+    """Merge prompt content from findings.
+
+    Returns:
+        Merged prompt text, or None if no prompts.
+    """
+    if not prompts:
+        return None
+
+    parts: list[str] = []
+    for finding in prompts:
+        if finding.content is None:
+            continue
+        if not isinstance(finding.content, PromptContent):
+            continue
+
+        content = finding.content.content
+        if not content:
+            continue
+
+        # Add source identifier
+        source = Path(finding.relative).name
+        parts.append(f"<!-- BEGIN: {source} -->")
+        parts.append(content.strip())
+        parts.append(f"<!-- END: {source} -->")
+        parts.append("")
+
+    return "\n".join(parts).strip() if parts else None
+
+
+def _pack_tools_from_findings(tools: list[Finding]) -> str | None:
+    """Merge tool schemas from findings into OpenAI function calling format.
+
+    Output format follows OpenAI function calling schema:
+    [
+      {
+        "type": "function",
+        "function": {
+          "name": "...",
+          "description": "...",
+          "parameters": {...}
+        }
+      }
+    ]
+
+    Returns:
+        JSON string of tools array, or None if no tools.
+    """
+    if not tools:
+        return None
+
+    all_tools: list[dict[str, Any]] = []
+    for finding in tools:
+        if finding.content is None:
+            continue
+        if not isinstance(finding.content, ToolContent):
+            continue
+
+        # Build OpenAI function calling format
+        tool_def = {
+            "type": "function",
+            "function": {
+                "name": finding.content.name,
+                "description": finding.content.description,
+                "parameters": finding.content.parameters,
+            },
+        }
+        all_tools.append(tool_def)
+
+    if not all_tools:
+        return None
+
+    return json.dumps(all_tools, ensure_ascii=False)
+
+
+def _pack_skills_from_findings(skills: list[Finding]) -> tuple[str, bytes] | None:
+    """Pack skills from findings.
+
+    For skill findings with content (from analyze_files mode), creates a
+    SKILL.md file in the ZIP. For directory findings (from scan mode),
+    reads files from disk.
+
+    Returns:
+        Tuple of (filename, bytes) for the ZIP, or None if no skills.
+    """
+    if not skills:
+        return None
+
+    buffer = BytesIO()
+
+    with zipfile.ZipFile(buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+        for i, finding in enumerate(skills):
+            skill_path = Path(finding.relative)
+
+            # Determine skill name
+            if finding.content and isinstance(finding.content, SkillContent):
+                skill_name = finding.content.name
+            else:
+                skill_name = skill_path.name if skill_path.is_dir() else f"skill_{i}"
+
+            if skill_path.is_file():
+                # Single skill file - read from disk
+                try:
+                    text_content = skill_path.read_text(encoding="utf-8")
+                    zf.writestr(f"{skill_name}/SKILL.md", text_content)
+                except OSError as e:
+                    warnings.warn(
+                        f"Could not read skill file for ZIP archive: {skill_path}: {e}", stacklevel=2
+                    )
+
+            elif skill_path.is_dir():
+                # Skill directory - add all files recursively
+                for file_path in skill_path.rglob("*"):
+                    if file_path.is_file():
+                        # Skip hidden files and excluded directories
+                        if any(part.startswith(".") for part in file_path.parts):
+                            continue
+                        if _is_excluded_path(file_path):
+                            continue
+
+                        rel_path = file_path.relative_to(skill_path)
+                        try:
+                            binary_content = file_path.read_bytes()
+                            zf.writestr(f"{skill_name}/{rel_path}", binary_content)
+                        except OSError as e:
+                            warnings.warn(
+                                f"Could not read file for ZIP archive: {file_path}: {e}", stacklevel=2
+                            )
+
+    return ("skills.zip", buffer.getvalue())

sanityops_cli/utils/config_loader.py

@@ -0,0 +1,296 @@
+# 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.
+#
+
+"""Inspect config loader - load and validate inspect_config.yaml"""
+
+import re
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from sanityops_cli.exceptions.base_exceptions import ValidationError
+
+# Default config file location
+DEFAULT_CONFIG_DIR = ".sanityops"
+DEFAULT_CONFIG_FILE = "inspect_config.yaml"
+
+# Sentinel project.id meaning "not yet bound". Kept as-is by init so that
+# the first inspect upload auto-creates the project and writes the real
+# id/name back to the config file.
+PROJECT_ID_PLACEHOLDER = "00000000-0000-0000-0000-000000000000"
+
+
+def read_file_with_encoding_fallback(path: Path) -> str | None:
+    """Read a file with UTF-8 encoding, falling back to GBK for Windows compatibility.
+
+    Args:
+        path: Path to the file to read
+
+    Returns:
+        File content as string, or None if file cannot be read with either encoding.
+    """
+    # Try UTF-8 first (most common)
+    try:
+        return path.read_text(encoding="utf-8")
+    except (UnicodeDecodeError, OSError):
+        pass
+
+    # Fall back to GBK (Windows Chinese locale)
+    try:
+        return path.read_text(encoding="gbk")
+    except (UnicodeDecodeError, OSError):
+        pass
+
+    return None
+
+
+class InspectConfigLoader:
+    """Load and validate inspect_config.yaml, resolve all artifact paths to absolute."""
+
+    def __init__(self, config_path: str | None = None):
+        self._config_path = self._resolve_config_path(config_path)
+        self._config = self._load_yaml()
+        self._root_dir = Path.cwd()
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    @property
+    def config_path(self) -> Path:
+        """Return the resolved config file path."""
+        return self._config_path
+
+    def load(self) -> dict[str, Any]:
+        """Load config, validate, and return resolved absolute paths.
+
+        Returns:
+            {
+                "project_id": str | None,  # None if placeholder (not bound)
+                "prompts": List[str],   # absolute paths
+                "tools": List[str],     # absolute paths
+                "skills": List[str],    # absolute paths
+            }
+
+        Note:
+            project.name in the config file is not returned here; it is
+            display metadata written back by the auto-upload flow.
+        """
+        self._validate_structure()
+
+        prompts = self._process_prompts()
+        tools = self._process_tools()
+        skills = self._process_skills()
+
+        if not prompts and not tools and not skills:
+            raise ValidationError(
+                "At least one of (prompts / tools / skills) must be provided in config"
+            )
+
+        # project_id may be None/placeholder if not bound
+        project_id = self._config["project"]["id"]
+        if project_id == PROJECT_ID_PLACEHOLDER:
+            project_id = None
+
+        return {
+            "project_id": project_id,
+            "prompts": prompts,
+            "tools": tools,
+            "skills": skills,
+        }
+
+    # ------------------------------------------------------------------
+    # Config path resolution
+    # ------------------------------------------------------------------
+
+    def _resolve_config_path(self, config_path: str | None) -> Path:
+        """Resolve config file path: explicit -> .sanityops/inspect_config.yaml -> error."""
+        if config_path:
+            p = Path(config_path).expanduser()
+            if not p.exists():
+                raise ValidationError(f"Config file not found: {config_path}")
+            if not p.is_file():
+                raise ValidationError(f"Config path is not a file: {config_path}")
+            return p.resolve()
+
+        # Fall back to default location in cwd
+        default_path = Path.cwd() / DEFAULT_CONFIG_DIR / DEFAULT_CONFIG_FILE
+        if default_path.exists() and default_path.is_file():
+            return default_path.resolve()
+
+        raise ValidationError(
+            f"Config file not found. Provide --config <path>, "
+            f"or create one at .sanityops/{DEFAULT_CONFIG_FILE}"
+        )
+
+    # ------------------------------------------------------------------
+    # YAML loading & structure validation
+    # ------------------------------------------------------------------
+
+    def _load_yaml(self) -> dict:
+        try:
+            with open(self._config_path, encoding="utf-8") as f:
+                data = yaml.safe_load(f)
+        except yaml.YAMLError as e:
+            raise ValidationError(f"Invalid YAML in config file: {e}") from e
+        except OSError as e:
+            raise ValidationError(f"Cannot read config file: {e}") from e
+
+        if not isinstance(data, dict):
+            raise ValidationError("Config file must contain a YAML object at top level")
+
+        return data
+
+    def _validate_structure(self) -> None:
+        # project.id is required
+        project = self._config.get("project")
+        if not isinstance(project, dict):
+            raise ValidationError("Config must contain 'project' section")
+        project_id = project.get("id")
+        if not project_id:
+            raise ValidationError("'project.id' is required (UUID)")
+        # validate UUID format
+        uuid_re = re.compile(
+            r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}"
+            r"-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
+        )
+        if not uuid_re.match(str(project_id)):
+            raise ValidationError(f"'project.id' is not a valid UUID: {project_id}")
+
+        # Validate model section if present
+        self._validate_model_section()
+
+    def _validate_model_section(self) -> None:
+        """Validate model section if present.
+
+        Rules:
+        - If 'model' key absent: OK (no validation)
+        - If 'model' present but not a dict: ValidationError
+        - Required fields: provider, api_key, model_id (non-empty strings)
+        - Optional: base_url (string, may be empty)
+        """
+        model = self._config.get("model")
+        if model is None:
+            return  # model section is optional
+
+        if not isinstance(model, dict):
+            raise ValidationError("'model' section must be a mapping (dict)")
+
+        # Required fields - must be non-empty strings
+        required_fields = ["provider", "api_key", "model_id"]
+        for field in required_fields:
+            value = model.get(field)
+            if value is None:
+                raise ValidationError(
+                    f"'model.{field}' is required when model section is present. "
+                    "Fill it in .sanityops/inspect_config.yaml, or remove the "
+                    "'model' section to use LLM_* environment variables instead."
+                )
+            if not isinstance(value, str):
+                raise ValidationError(f"'model.{field}' must be a string")
+            if value.strip() == "":
+                raise ValidationError(
+                    f"'model.{field}' cannot be empty. "
+                    "Fill it in .sanityops/inspect_config.yaml, or remove the "
+                    "'model' section to use LLM_* environment variables instead."
+                )
+
+        # Optional field - just check it's a string if present
+        base_url = model.get("base_url")
+        if base_url is not None and not isinstance(base_url, str):
+            raise ValidationError("'model.base_url' must be a string")
+
+    # ------------------------------------------------------------------
+    # Path resolution helper
+    # ------------------------------------------------------------------
+
+    def _resolve_file_path(self, file_str: str) -> Path:
+        """Resolve a file path to absolute, handling relative paths against root dir."""
+        p = Path(file_str).expanduser()
+        if not p.is_absolute():
+            p = self._root_dir / p
+        return p.resolve()
+
+    # ------------------------------------------------------------------
+    # Prompts processing
+    # ------------------------------------------------------------------
+
+    def _process_prompts(self) -> list[str]:
+        """Validate prompt files and return absolute paths."""
+        entries = self._config.get("prompts", [])
+        if entries is None:
+            entries = []
+        return self._process_file_entries(entries, "prompts")
+
+    # ------------------------------------------------------------------
+    # Tools processing
+    # ------------------------------------------------------------------
+
+    def _process_tools(self) -> list[str]:
+        """Validate tool files and return absolute paths."""
+        entries = self._config.get("tools", [])
+        if entries is None:
+            entries = []
+        return self._process_file_entries(entries, "tools")
+
+    def _process_file_entries(self, entries: list, label: str) -> list[str]:
+        """Common logic for prompts, tools, and skills: each entry must be a readable file."""
+        result: list[str] = []
+        for i, entry in enumerate(entries):
+            file_str = self._extract_file_value(entry, label, i)
+            abs_path = self._resolve_file_path(file_str)
+            if not abs_path.exists():
+                raise ValidationError(
+                    f"[{label}] file not found: {file_str} (resolved: {abs_path})"
+                )
+            if not abs_path.is_file():
+                raise ValidationError(
+                    f"[{label}] path is not a file: {file_str} (resolved: {abs_path})"
+                )
+            result.append(str(abs_path))
+        return result
+
+    # ------------------------------------------------------------------
+    # Skills processing
+    # ------------------------------------------------------------------
+
+    def _process_skills(self) -> list[str]:
+        """Validate skill files and return absolute paths (files only)."""
+        entries = self._config.get("skills", [])
+        if entries is None:
+            entries = []
+        return self._process_file_entries(entries, "skills")
+
+    # ------------------------------------------------------------------
+    # Entry parsing helper
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _extract_file_value(entry, label: str, index: int) -> str:
+        """Extract 'file' value from a YAML list entry."""
+        if isinstance(entry, dict):
+            file_val = entry.get("file")
+            if not file_val:
+                raise ValidationError(
+                    f"[{label}] entry #{index} missing 'file' key"
+                )
+            return str(file_val)
+        elif isinstance(entry, str):
+            return entry
+        else:
+            raise ValidationError(
+                f"[{label}] entry #{index} must be a string or object with 'file' key"
+            )