oasr 0.5.2__py3-none-any.whl → 0.6.0__py3-none-any.whl

agents/base.py

@@ -34,25 +34,39 @@ class AgentDriver(ABC):
         return shutil.which(self.get_binary_name()) is not None
 
     @abstractmethod
-    def build_command(self, skill_content: str, user_prompt: str, cwd: Path) -> list[str]:
+    def build_command(
+        self,
+        skill_content: str,
+        user_prompt: str,
+        cwd: Path,
+        extra_args: list[str] | None = None,
+    ) -> list[str]:
         """Build the command to execute.
 
         Args:
             skill_content: Full SKILL.md content.
             user_prompt: User's prompt/request.
             cwd: Current working directory.
+            extra_args: Additional CLI arguments for the agent (optional).
 
         Returns:
             Command as list of strings (for subprocess).
         """
 
-    def execute(self, skill_content: str, user_prompt: str, cwd: Path | None = None) -> subprocess.CompletedProcess:
+    def execute(
+        self,
+        skill_content: str,
+        user_prompt: str,
+        cwd: Path | None = None,
+        extra_args: list[str] | None = None,
+    ) -> subprocess.CompletedProcess:
         """Execute skill with agent.
 
         Args:
             skill_content: Full SKILL.md content.
             user_prompt: User's prompt/request.
             cwd: Working directory for execution (defaults to current dir).
+            extra_args: Additional CLI arguments for the agent (optional).
 
         Returns:
             CompletedProcess with stdout/stderr/returncode.
@@ -64,7 +78,7 @@ class AgentDriver(ABC):
             raise FileNotFoundError(f"{self.get_name()} binary '{self.get_binary_name()}' not found in PATH")
 
         working_dir = cwd or Path.cwd()
-        cmd = self.build_command(skill_content, user_prompt, working_dir)
+        cmd = self.build_command(skill_content, user_prompt, working_dir, extra_args=extra_args)
 
         return subprocess.run(
             cmd,

agents/claude.py

@@ -16,10 +16,20 @@ class ClaudeDriver(AgentDriver):
         """Get the CLI binary name."""
         return "claude"
 
-    def build_command(self, skill_content: str, user_prompt: str, cwd: Path) -> list[str]:
+    def build_command(
+        self,
+        skill_content: str,
+        user_prompt: str,
+        cwd: Path,
+        extra_args: list[str] | None = None,
+    ) -> list[str]:
         """Build claude command.
 
         Claude syntax: claude <prompt> -p
         """
         injected_prompt = self.format_injected_prompt(skill_content, user_prompt, cwd)
-        return ["claude", injected_prompt, "-p"]
+        cmd = ["claude"]
+        if extra_args:
+            cmd.extend(extra_args)
+        cmd.extend([injected_prompt, "-p"])
+        return cmd

agents/codex.py

@@ -16,10 +16,20 @@ class CodexDriver(AgentDriver):
         """Get the CLI binary name."""
         return "codex"
 
-    def build_command(self, skill_content: str, user_prompt: str, cwd: Path) -> list[str]:
+    def build_command(
+        self,
+        skill_content: str,
+        user_prompt: str,
+        cwd: Path,
+        extra_args: list[str] | None = None,
+    ) -> list[str]:
         """Build codex exec command.
 
         Codex syntax: codex exec "<prompt>"
         """
         injected_prompt = self.format_injected_prompt(skill_content, user_prompt, cwd)
-        return ["codex", "exec", injected_prompt]
+        cmd = ["codex", "exec"]
+        if extra_args:
+            cmd.extend(extra_args)
+        cmd.append(injected_prompt)
+        return cmd

agents/copilot.py

@@ -16,10 +16,20 @@ class CopilotDriver(AgentDriver):
         """Get the CLI binary name."""
         return "copilot"
 
-    def build_command(self, skill_content: str, user_prompt: str, cwd: Path) -> list[str]:
+    def build_command(
+        self,
+        skill_content: str,
+        user_prompt: str,
+        cwd: Path,
+        extra_args: list[str] | None = None,
+    ) -> list[str]:
         """Build copilot command.
 
         Copilot syntax: copilot -p "<prompt>"
         """
         injected_prompt = self.format_injected_prompt(skill_content, user_prompt, cwd)
-        return ["copilot", "-p", injected_prompt]
+        cmd = ["copilot"]
+        if extra_args:
+            cmd.extend(extra_args)
+        cmd.extend(["-p", injected_prompt])
+        return cmd

agents/opencode.py

@@ -16,10 +16,20 @@ class OpenCodeDriver(AgentDriver):
         """Get the CLI binary name."""
         return "opencode"
 
-    def build_command(self, skill_content: str, user_prompt: str, cwd: Path) -> list[str]:
+    def build_command(
+        self,
+        skill_content: str,
+        user_prompt: str,
+        cwd: Path,
+        extra_args: list[str] | None = None,
+    ) -> list[str]:
         """Build opencode run command.
 
         OpenCode syntax: opencode run "<prompt>"
         """
         injected_prompt = self.format_injected_prompt(skill_content, user_prompt, cwd)
-        return ["opencode", "run", injected_prompt]
+        cmd = ["opencode", "run"]
+        if extra_args:
+            cmd.extend(extra_args)
+        cmd.append(injected_prompt)
+        return cmd

cli.py

@@ -10,10 +10,10 @@ import json
 import sys
 from pathlib import Path
 
-from commands import adapter, clean, clone, config, diff, exec, find, registry, sync, update, use, validate
+from commands import adapter, clean, clone, config, diff, exec, find, profile, registry, sync, update, use, validate
 from commands import help as help_cmd
 
-__version__ = "0.5.2"
+__version__ = "0.6.0"
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -72,6 +72,7 @@ def create_parser() -> argparse.ArgumentParser:
     diff.register(subparsers)  # Show tracked skill status
     sync.register(subparsers)  # Refresh tracked skills
     config.register(subparsers)  # Configuration management
+    profile.register(subparsers)  # Profile selection
     clone.register(subparsers)  # Clone skills to directory
     exec.register(subparsers)  # Execute skills with agent CLI
 

commands/config.py

@@ -2,10 +2,20 @@
 
 import argparse
 import sys
+from pathlib import Path
+from typing import Any
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
 
 from agents import detect_available_agents
-from config import CONFIG_FILE, load_config, save_config
+from config import CONFIG_FILE, get_default_config, load_config, save_config
 from config.schema import validate_agent, validate_profile_reference
+from profiles.builtins import BUILTIN_PROFILES
+from profiles.loader import list_profile_files, load_profiles
+from profiles.summary import format_profile_summary, sorted_profile_names
 
 
 def register(subparsers: argparse._SubParsersAction) -> None:
@@ -50,6 +60,63 @@ def register(subparsers: argparse._SubParsersAction) -> None:
     )
     list_parser.set_defaults(func=run_list)
 
+    # config agent
+    agent_parser = config_subparsers.add_parser(
+        "agent",
+        help="Show agent configuration",
+        description="Show default agent configuration and availability",
+    )
+    agent_parser.set_defaults(func=run_agent)
+
+    # config validation
+    validation_parser = config_subparsers.add_parser(
+        "validation",
+        help="Show validation settings",
+        description="Show validation configuration settings",
+    )
+    validation_parser.set_defaults(func=run_validation)
+
+    # config adapter
+    adapter_parser = config_subparsers.add_parser(
+        "adapter",
+        help="Show adapter settings",
+        description="Show adapter configuration settings",
+    )
+    adapter_parser.set_defaults(func=run_adapter)
+
+    # config oasr
+    oasr_parser = config_subparsers.add_parser(
+        "oasr",
+        help="Show core OASR settings",
+        description="Show core OASR configuration settings",
+    )
+    oasr_parser.set_defaults(func=run_oasr)
+
+    # config profiles
+    profiles_parser = config_subparsers.add_parser(
+        "profiles",
+        help="Show execution profiles",
+        description="Show available execution policy profiles",
+    )
+    profiles_parser.add_argument("--names", action="store_true", help="Output profile names only")
+    profiles_parser.set_defaults(func=run_profiles)
+
+    # config man
+    man_parser = config_subparsers.add_parser(
+        "man",
+        help="Show configuration reference",
+        description="Show configuration reference with examples",
+    )
+    man_parser.set_defaults(func=run_man)
+
+    # config validate
+    validate_parser = config_subparsers.add_parser(
+        "validate",
+        help="Validate config file",
+        description="Validate configuration file structure and values",
+    )
+    validate_parser.set_defaults(func=run_validate)
+
     # config path
     path_parser = config_subparsers.add_parser(
         "path",
@@ -62,43 +129,82 @@ def register(subparsers: argparse._SubParsersAction) -> None:
     parser.set_defaults(func=lambda args: parser.print_help() or 1)
 
 
+def _load_file_config(config_path: Path) -> dict[str, Any]:
+    if config_path.exists():
+        with open(config_path, "rb") as f:
+            data = tomllib.load(f)
+        if isinstance(data, dict):
+            return data
+    return {}
+
+
+def _parse_key(key: str) -> tuple[str, str]:
+    key = key.lower()
+    aliases = {
+        "agent": ("agent", "default"),
+        "profile": ("oasr", "default_profile"),
+    }
+    if key in aliases:
+        return aliases[key]
+    if "." in key:
+        parts = key.split(".", 1)
+        if len(parts) != 2:
+            raise ValueError(f"Invalid key '{key}'. Use format 'section.field' or 'agent'")
+        return parts[0], parts[1]
+    raise ValueError(f"Invalid key '{key}'. Use format 'section.field' or 'agent'")
+
+
+def _format_value(value: Any) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, list):
+        return ", ".join(str(item) for item in value)
+    return str(value)
+
+
+def _parse_bool(value: str, field: str) -> bool:
+    value_lower = value.lower()
+    if value_lower in ("true", "1", "yes", "on"):
+        return True
+    if value_lower in ("false", "0", "no", "off"):
+        return False
+    raise ValueError(f"'{field}' must be a boolean")
+
+
 def run_set(args: argparse.Namespace) -> int:
     """Set a configuration value with validation."""
     key = args.key.lower()
     value = args.value
     force = getattr(args, "force", False)
 
-    # Parse key (support dotted notation like "validation.strict")
-    if "." in key:
-        parts = key.split(".", 1)
-        if len(parts) != 2:
-            print(f"Error: Invalid key '{key}'. Use format 'section.field' or 'agent'", file=sys.stderr)
-            return 1
-        section, field = parts
-    elif key == "agent":
-        # Special case: bare "agent" means "agent.default"
-        section, field = "agent", "default"
-    else:
-        print(f"Error: Invalid key '{key}'. Use format 'section.field' or 'agent'", file=sys.stderr)
+    try:
+        section, field = _parse_key(key)
+    except ValueError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
         return 1
 
     # Type coercion based on field
     original_value = value
-    if field == "strict":
-        value = value.lower() in ("true", "1", "yes", "on")
-    elif field == "reference_max_lines":
-        try:
+    try:
+        if field in ("strict", "completions"):
+            value = _parse_bool(value, field)
+        elif field == "reference_max_lines":
             value = int(value)
             if value < 1:
-                print(f"Error: '{field}' must be a positive integer", file=sys.stderr)
-                return 1
-        except ValueError:
-            print(f"Error: '{field}' must be an integer", file=sys.stderr)
-            return 1
+                raise ValueError(f"'{field}' must be a positive integer")
+        elif field == "default_targets":
+            value = [item.strip() for item in value.split(",") if item.strip()]
+        elif field == "default_profile":
+            value = value.strip()
+    except ValueError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        return 1
 
     # Load config
     config_path = getattr(args, "config", None)
+    config_file_path = config_path or CONFIG_FILE
     config = load_config(config_path=config_path)
+    file_config = _load_file_config(config_file_path)
 
     # Validate before setting (unless --force)
     if not force:
@@ -115,18 +221,18 @@ def run_set(args: argparse.Namespace) -> int:
             is_valid, error_msg = validate_profile_reference(value, config)
             if not is_valid:
                 print(f"Error: {error_msg}", file=sys.stderr)
-                print("\nCreate the profile in ~/.oasr/config.toml first, or use:", file=sys.stderr)
+                print("\nCreate the profile in ~/.oasr/config.toml or ~/.oasr/profile/, or use:", file=sys.stderr)
                 print(f"  oasr config set --force oasr.default_profile {value}", file=sys.stderr)
                 return 1
 
     # Set the value
-    if section not in config:
-        config[section] = {}
+    if section not in file_config:
+        file_config[section] = {}
 
-    config[section][field] = value
+    file_config[section][field] = value
 
     try:
-        save_config(config, config_path=config_path)
+        save_config(file_config, config_path=config_file_path)
 
         # Show confirmation
         if section == "agent" and field == "default":
@@ -137,6 +243,8 @@ def run_set(args: argparse.Namespace) -> int:
             else:
                 print(f"✓ Default agent set to: {value}")
                 print(f"  Warning: '{value}' binary not found in PATH. Install it to use this agent.", file=sys.stderr)
+        elif section == "oasr" and field == "default_profile":
+            print(f"✓ Default profile set to: {value}")
         else:
             print(f"✓ Set {section}.{field} = {original_value}")
 
@@ -152,18 +260,20 @@ def run_get(args: argparse.Namespace) -> int:
 
     config = load_config(args.config if hasattr(args, "config") else None)
 
-    if key == "agent":
-        agent = config["agent"].get("default")
-        if agent:
-            print(agent)
-        else:
-            print("No default agent configured", file=sys.stderr)
-            return 1
-        return 0
-    else:
-        print(f"Error: Unsupported config key '{key}'. Only 'agent' is supported.", file=sys.stderr)
+    try:
+        section, field = _parse_key(key)
+    except ValueError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
         return 1
 
+    value = config.get(section, {}).get(field)
+    if value is None:
+        print(f"Config value not set: {section}.{field}", file=sys.stderr)
+        return 1
+
+    print(_format_value(value))
+    return 0
+
 
 def run_list(args: argparse.Namespace) -> int:
     """List all configuration."""
@@ -202,9 +312,146 @@ def run_list(args: argparse.Namespace) -> int:
     print(f"    default_targets = {config['adapter']['default_targets']}")
     print()
 
+    # OASR section
+    print("  [oasr]")
+    print(f"    default_profile = {config['oasr']['default_profile']}")
+    print(f"    completions = {_format_value(config['oasr']['completions'])}")
+    print()
+
+    # Profiles section
+    print("  [profiles]")
+    profiles = config.get("profiles", {})
+    for name in sorted_profile_names(profiles):
+        profile = profiles[name]
+        summary = format_profile_summary(name, profile)
+        print(f"    {summary}")
+    print()
+
+    return 0
+
+
+def run_agent(args: argparse.Namespace) -> int:
+    config = load_config(args.config if hasattr(args, "config") else None)
+    agent = config["agent"].get("default")
+    available = detect_available_agents()
+
+    print("Agent configuration:")
+    print(f"  Default: {agent or '(not set)'}")
+    print()
+    if available:
+        print("Available agents:")
+        for name in sorted(available):
+            print(f"  ✓ {name}")
+    else:
+        print("Available agents: (none detected)")
+    return 0
+
+
+def run_validation(args: argparse.Namespace) -> int:
+    config = load_config(args.config if hasattr(args, "config") else None)
+    validation = config.get("validation", {})
+    print("Validation settings:")
+    print(f"  reference_max_lines: {validation.get('reference_max_lines')}")
+    print(f"  strict: {validation.get('strict')}")
+    return 0
+
+
+def run_adapter(args: argparse.Namespace) -> int:
+    config = load_config(args.config if hasattr(args, "config") else None)
+    adapter = config.get("adapter", {})
+    targets = adapter.get("default_targets", [])
+    print("Adapter settings:")
+    print(f"  default_targets: {', '.join(targets)}")
+    return 0
+
+
+def run_oasr(args: argparse.Namespace) -> int:
+    config = load_config(args.config if hasattr(args, "config") else None)
+    oasr = config.get("oasr", {})
+    print("OASR settings:")
+    print(f"  default_profile: {oasr.get('default_profile')}")
+    print(f"  completions: {_format_value(oasr.get('completions'))}")
     return 0
 
 
+def run_profiles(args: argparse.Namespace) -> int:
+    config = load_config(args.config if hasattr(args, "config") else None)
+    profiles = config.get("profiles", {})
+    names = sorted_profile_names(profiles)
+
+    if args.names:
+        print("\n".join(names))
+        return 0
+
+    print("Profiles:")
+    for name in names:
+        summary = format_profile_summary(name, profiles[name])
+        suffix = " (built-in)" if name in BUILTIN_PROFILES else ""
+        print(f"  {summary}{suffix}")
+    print("\nProfile files: ~/.oasr/profile/*.toml (inline config overrides)")
+    return 0
+
+
+def run_man(args: argparse.Namespace) -> int:
+    print("OASR configuration reference")
+    print()
+    print("Quick reference:")
+    print("  oasr config set <key> <value>")
+    print("  oasr config get <key>")
+    print("  oasr config list")
+    print("  oasr config path")
+    print("  oasr config validate")
+    print()
+    print("Common keys:")
+    print("  agent")
+    print("  oasr.default_profile")
+    print("  oasr.completions")
+    print("  validation.strict")
+    print("  validation.reference_max_lines")
+    print("  adapter.default_targets")
+    print()
+    print("Examples:")
+    print("  oasr config set agent codex")
+    print("  oasr config set oasr.default_profile dev")
+    print("  oasr config set validation.strict true")
+    print("  oasr config set adapter.default_targets cursor,windsurf")
+    print()
+    print("Profiles:")
+    print("  - Built-ins: safe, strict, dev, unsafe")
+    print("  - Inline: [profiles.<name>] in config.toml")
+    print("  - Files: ~/.oasr/profile/<name>.toml (body keys only)")
+    print()
+    print("Docs: docs/commands/CONFIG.md and docs/configuration/README.md")
+    return 0
+
+
+def run_validate(args: argparse.Namespace) -> int:
+    config_path = args.config if hasattr(args, "config") and args.config else CONFIG_FILE
+    if not config_path.exists():
+        defaults = get_default_config()
+        try:
+            save_config(defaults, config_path=config_path)
+            print(f"✓ Created default config at {config_path}")
+        except ValueError as exc:
+            print(f"Error: {exc}", file=sys.stderr)
+            return 1
+
+    try:
+        file_config = _load_file_config(config_path)
+        if not isinstance(file_config, dict):
+            raise ValueError("Config file must contain a table")
+        inline_profiles = file_config.get("profiles", {})
+        _ = load_profiles(inline_profiles=inline_profiles if isinstance(inline_profiles, dict) else {})
+        save_config(file_config, config_path=config_path)
+        print(f"✓ Config valid: {config_path}")
+        if list_profile_files():
+            print("✓ Profile files loaded")
+        return 0
+    except ValueError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        return 1
+
+
 def run_path(args: argparse.Namespace) -> int:
     """Show config file path."""
     if hasattr(args, "config") and args.config:

commands/exec.py

@@ -43,6 +43,11 @@ def setup_parser(subparsers):
         "--agent",
         help="Override the default agent (codex, copilot, claude, opencode)",
     )
+    parser.add_argument(
+        "--unsafe",
+        action="store_true",
+        help="Pass unsafe mode flags to the agent CLI (use with caution)",
+    )
     parser.add_argument(
         "--profile",
         help="Execution policy profile to use (default: from config)",
@@ -161,7 +166,22 @@ def run(args: argparse.Namespace) -> int:
     print("━" * 60, file=sys.stderr)
 
     try:
-        result = driver.execute(skill_content, user_prompt)
+        extra_args = []
+        if getattr(args, "unsafe", False):
+            if agent_name == "codex":
+                extra_args.append("--skip-git-repo-check")
+            elif agent_name == "claude":
+                extra_args.append("--dangerously-skip-permissions")
+            else:
+                print(
+                    f"Warning: --unsafe is not supported for agent '{agent_name}'.",
+                    file=sys.stderr,
+                )
+                print(
+                    "See agent docs for trusted directory or permission configuration.",
+                    file=sys.stderr,
+                )
+        result = driver.execute(skill_content, user_prompt, extra_args=extra_args or None)
         # CompletedProcess has returncode attribute (0 = success)
         # Output was already streamed to stdout since capture_output=False
         return result.returncode

commands/profile.py

@@ -0,0 +1,84 @@
+"""`oasr profile` command."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+import questionary
+
+from config import CONFIG_FILE, load_config, save_config
+from profiles import BUILTIN_PROFILES, format_profile_summary, sorted_profile_names
+
+
+def register(subparsers: argparse._SubParsersAction) -> None:
+    parser = subparsers.add_parser(
+        "profile",
+        help="List or set execution profiles",
+        description="List and select execution policy profiles",
+    )
+    parser.add_argument("name", nargs="?", help="Profile name to set as default")
+    parser.set_defaults(func=run)
+
+
+def _print_profiles(profiles: dict[str, dict[str, object]], current: str) -> None:
+    names = sorted_profile_names(profiles)
+    print("Profiles:")
+    for name in names:
+        summary = format_profile_summary(name, profiles[name])
+        suffix = []
+        if name == current:
+            suffix.append("current")
+        if name in BUILTIN_PROFILES:
+            suffix.append("built-in")
+        suffix_text = f" ({', '.join(suffix)})" if suffix else ""
+        print(f"  {summary}{suffix_text}")
+
+
+def _select_profile(names: list[str], current: str) -> str | None:
+    default_choice = current if current in names else (names[0] if names else None)
+    if not default_choice:
+        return None
+    response = questionary.select(
+        "Select a default profile:",
+        choices=names,
+        default=default_choice,
+    ).ask()
+    return response
+
+
+def _set_default_profile(config_path: Path, profile_name: str) -> int:
+    config = load_config(config_path=config_path)
+    profiles = config.get("profiles", {})
+    if profile_name not in profiles:
+        print(f"Error: Profile '{profile_name}' not found.", file=sys.stderr)
+        return 1
+
+    config["oasr"]["default_profile"] = profile_name
+    save_config(config, config_path=config_path)
+    print(f"✓ Default profile set to: {profile_name}")
+    return 0
+
+
+def run(args: argparse.Namespace) -> int:
+    config_path = CONFIG_FILE
+    config = load_config(config_path=config_path)
+    profiles = config.get("profiles", {})
+    current = config.get("oasr", {}).get("default_profile", "safe")
+
+    if args.name:
+        return _set_default_profile(config_path, args.name)
+
+    if not sys.stdout.isatty() or not sys.stdin.isatty():
+        _print_profiles(profiles, current)
+        print("\nTip: run `oasr profile <name>` to set the default profile.", file=sys.stderr)
+        return 0
+
+    names = sorted_profile_names(profiles)
+    choice = _select_profile(names, current)
+    if not choice:
+        print("No profiles available.", file=sys.stderr)
+        return 1
+
+    return _set_default_profile(config_path, choice)