oasr 0.5.0__py3-none-any.whl

config/__init__.py

@@ -0,0 +1,119 @@
+"""Configuration management for ~/.oasr/config.toml."""
+
+import sys
+from pathlib import Path
+from typing import Any
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+
+import tomli_w
+
+from config.defaults import DEFAULT_CONFIG
+from config.schema import validate_config
+
+OASR_DIR = Path.home() / ".oasr"
+CONFIG_FILE = OASR_DIR / "config.toml"
+
+__all__ = [
+    "OASR_DIR",
+    "CONFIG_FILE",
+    "ensure_oasr_dir",
+    "ensure_skills_dir",
+    "load_config",
+    "save_config",
+    "get_default_config",
+]
+
+
+def ensure_oasr_dir() -> Path:
+    """Ensure ~/.oasr/ directory exists."""
+    OASR_DIR.mkdir(parents=True, exist_ok=True)
+    return OASR_DIR
+
+
+# Legacy alias for backwards compatibility
+def ensure_skills_dir() -> Path:
+    """Legacy alias for ensure_oasr_dir()."""
+    return ensure_oasr_dir()
+
+
+def load_config(config_path: Path | None = None) -> dict[str, Any]:
+    """Load configuration from TOML file.
+
+    Args:
+        config_path: Override config file path. Defaults to ~/.oasr/config.toml.
+
+    Returns:
+        Configuration dictionary with defaults applied.
+    """
+    path = config_path or CONFIG_FILE
+
+    # Deep copy defaults
+    config = {
+        "validation": DEFAULT_CONFIG["validation"].copy(),
+        "adapter": DEFAULT_CONFIG["adapter"].copy(),
+        "agent": DEFAULT_CONFIG["agent"].copy(),
+        "oasr": DEFAULT_CONFIG["oasr"].copy(),
+        "profiles": {k: v.copy() for k, v in DEFAULT_CONFIG["profiles"].items()},
+    }
+
+    if path.exists():
+        with open(path, "rb") as f:
+            loaded = tomllib.load(f)
+
+        if "validation" in loaded:
+            config["validation"].update(loaded["validation"])
+        if "adapter" in loaded:
+            config["adapter"].update(loaded["adapter"])
+        if "agent" in loaded:
+            config["agent"].update(loaded["agent"])
+        if "oasr" in loaded:
+            config["oasr"].update(loaded["oasr"])
+        if "profiles" in loaded:
+            # Merge user profiles with defaults (user profiles take precedence)
+            for profile_name, profile_data in loaded["profiles"].items():
+                config["profiles"][profile_name] = profile_data
+
+    return config
+
+
+def save_config(config: dict[str, Any], config_path: Path | None = None) -> None:
+    """Save configuration to TOML file.
+
+    Args:
+        config: Configuration dictionary to save.
+        config_path: Override config file path. Defaults to ~/.oasr/config.toml.
+
+    Raises:
+        ValueError: If configuration is invalid.
+    """
+    validate_config(config)
+
+    path = config_path or CONFIG_FILE
+    ensure_oasr_dir()
+
+    # Deep copy and remove None values (TOML can't serialize None)
+    config_to_save = {}
+    for section, values in config.items():
+        if isinstance(values, dict):
+            config_to_save[section] = {k: v for k, v in values.items() if v is not None}
+        else:
+            if values is not None:
+                config_to_save[section] = values
+
+    with open(path, "wb") as f:
+        tomli_w.dump(config_to_save, f)
+
+
+def get_default_config() -> dict[str, Any]:
+    """Return a copy of the default configuration."""
+    return {
+        "validation": DEFAULT_CONFIG["validation"].copy(),
+        "adapter": DEFAULT_CONFIG["adapter"].copy(),
+        "agent": DEFAULT_CONFIG["agent"].copy(),
+        "oasr": DEFAULT_CONFIG["oasr"].copy(),
+        "profiles": {k: v.copy() for k, v in DEFAULT_CONFIG["profiles"].items()},
+    }

config/defaults.py

@@ -0,0 +1,40 @@
+"""Default configuration values."""
+
+from typing import Any
+
+DEFAULT_CONFIG: dict[str, Any] = {
+    "validation": {
+        "reference_max_lines": 500,
+        "strict": False,
+    },
+    "adapter": {
+        "default_targets": ["cursor", "windsurf"],
+    },
+    "agent": {
+        "default": None,
+    },
+    "oasr": {
+        "default_profile": "safe",
+    },
+    "profiles": {
+        # Built-in safe profile (always available as fallback)
+        "safe": {
+            "fs_read_roots": ["./"],
+            "fs_write_roots": ["./out", "./.oasr"],
+            "deny_paths": [
+                "~/.ssh",
+                "~/.aws",
+                "~/.gnupg",
+                "~/.config",
+                ".env",
+                "~/.bashrc",
+                "~/.zshrc",
+                "~/.profile",
+            ],
+            "allowed_commands": ["rg", "fd", "jq", "cat"],
+            "deny_shell": True,
+            "network": False,
+            "allow_env": False,
+        },
+    },
+}

config/schema.py

@@ -0,0 +1,73 @@
+"""Configuration schema validation."""
+
+from typing import Any
+
+VALID_AGENTS = {"codex", "copilot", "claude", "opencode"}
+
+
+def validate_config(config: dict[str, Any]) -> None:
+    """Validate configuration dictionary.
+
+    Args:
+        config: Configuration dictionary to validate.
+
+    Raises:
+        ValueError: If configuration is invalid.
+    """
+    if "agent" in config and "default" in config["agent"]:
+        agent = config["agent"]["default"]
+        if agent is not None and agent not in VALID_AGENTS:
+            raise ValueError(f"Invalid agent '{agent}'. Must be one of: {', '.join(sorted(VALID_AGENTS))}")
+
+    if "validation" in config:
+        if "reference_max_lines" in config["validation"]:
+            max_lines = config["validation"]["reference_max_lines"]
+            if not isinstance(max_lines, int) or max_lines < 1:
+                raise ValueError("validation.reference_max_lines must be a positive integer")
+
+        if "strict" in config["validation"]:
+            if not isinstance(config["validation"]["strict"], bool):
+                raise ValueError("validation.strict must be a boolean")
+
+    if "adapter" in config:
+        if "default_targets" in config["adapter"]:
+            targets = config["adapter"]["default_targets"]
+            if not isinstance(targets, list):
+                raise ValueError("adapter.default_targets must be a list")
+
+    if "oasr" in config:
+        if "default_profile" in config["oasr"]:
+            profile = config["oasr"]["default_profile"]
+            if not isinstance(profile, str):
+                raise ValueError("oasr.default_profile must be a string")
+
+    if "profiles" in config:
+        if not isinstance(config["profiles"], dict):
+            raise ValueError("profiles must be a table (dictionary)")
+
+        # Validate each profile structure
+        for profile_name, profile_data in config["profiles"].items():
+            if not isinstance(profile_data, dict):
+                raise ValueError(f"Profile '{profile_name}' must be a table (dictionary)")
+
+            # Validate profile fields if present
+            if "fs_read_roots" in profile_data and not isinstance(profile_data["fs_read_roots"], list):
+                raise ValueError(f"Profile '{profile_name}': fs_read_roots must be a list")
+
+            if "fs_write_roots" in profile_data and not isinstance(profile_data["fs_write_roots"], list):
+                raise ValueError(f"Profile '{profile_name}': fs_write_roots must be a list")
+
+            if "deny_paths" in profile_data and not isinstance(profile_data["deny_paths"], list):
+                raise ValueError(f"Profile '{profile_name}': deny_paths must be a list")
+
+            if "allowed_commands" in profile_data and not isinstance(profile_data["allowed_commands"], list):
+                raise ValueError(f"Profile '{profile_name}': allowed_commands must be a list")
+
+            if "deny_shell" in profile_data and not isinstance(profile_data["deny_shell"], bool):
+                raise ValueError(f"Profile '{profile_name}': deny_shell must be a boolean")
+
+            if "network" in profile_data and not isinstance(profile_data["network"], bool):
+                raise ValueError(f"Profile '{profile_name}': network must be a boolean")
+
+            if "allow_env" in profile_data and not isinstance(profile_data["allow_env"], bool):
+                raise ValueError(f"Profile '{profile_name}': allow_env must be a boolean")

discovery.py

@@ -0,0 +1,145 @@
+"""Discovery module for finding SKILL.md files recursively."""
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import yaml
+
+
+@dataclass
+class DiscoveredSkill:
+    """A discovered skill from filesystem."""
+
+    path: Path
+    name: str
+    description: str
+    raw_frontmatter: dict | None = None
+
+
+def parse_frontmatter(content: str) -> dict | None:
+    """Parse YAML frontmatter from markdown content.
+
+    Args:
+        content: Markdown file content.
+
+    Returns:
+        Parsed frontmatter dictionary, or None if not found/invalid.
+    """
+    if not content.startswith("---"):
+        return None
+
+    lines = content.split("\n")
+    end_idx = None
+
+    for i, line in enumerate(lines[1:], start=1):
+        if line.strip() == "---":
+            end_idx = i
+            break
+
+    if end_idx is None:
+        return None
+
+    frontmatter_text = "\n".join(lines[1:end_idx])
+
+    try:
+        return yaml.safe_load(frontmatter_text)
+    except yaml.YAMLError:
+        return None
+
+
+def extract_skill_info(skill_md_path: Path) -> tuple[str, str, dict | None]:
+    """Extract name and description from SKILL.md.
+
+    Args:
+        skill_md_path: Path to SKILL.md file.
+
+    Returns:
+        Tuple of (name, description, raw_frontmatter).
+        Name/description default to empty string if not found.
+    """
+    try:
+        content = skill_md_path.read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError):
+        return "", "", None
+
+    frontmatter = parse_frontmatter(content)
+
+    if frontmatter is None:
+        return "", "", None
+
+    name = frontmatter.get("name", "")
+    description = frontmatter.get("description", "")
+
+    if isinstance(name, str):
+        name = name.strip()
+    else:
+        name = ""
+
+    if isinstance(description, str):
+        description = " ".join(description.split())
+    else:
+        description = ""
+
+    return name, description, frontmatter
+
+
+def find_skills(root: Path) -> list[DiscoveredSkill]:
+    """Find all skills recursively under a root directory.
+
+    Args:
+        root: Root directory to search.
+
+    Returns:
+        List of discovered skills.
+    """
+    skills = []
+    root = root.resolve()
+
+    if not root.is_dir():
+        return skills
+
+    for skill_md in root.rglob("SKILL.md"):
+        skill_dir = skill_md.parent
+        name, description, frontmatter = extract_skill_info(skill_md)
+
+        if not name:
+            name = skill_dir.name
+
+        skills.append(
+            DiscoveredSkill(
+                path=skill_dir,
+                name=name,
+                description=description,
+                raw_frontmatter=frontmatter,
+            )
+        )
+
+    return skills
+
+
+def discover_single(path: Path) -> DiscoveredSkill | None:
+    """Discover a single skill at a given path.
+
+    Args:
+        path: Path to skill directory (containing SKILL.md).
+
+    Returns:
+        Discovered skill, or None if not a valid skill.
+    """
+    path = path.resolve()
+    skill_md = path / "SKILL.md"
+
+    if not skill_md.exists():
+        return None
+
+    name, description, frontmatter = extract_skill_info(skill_md)
+
+    if not name:
+        name = path.name
+
+    return DiscoveredSkill(
+        path=path,
+        name=name,
+        description=description,
+        raw_frontmatter=frontmatter,
+    )