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

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)

commands/update.py

@@ -6,6 +6,8 @@ import argparse
 import json
 import subprocess
 import sys
+import urllib.request
+from importlib import metadata
 from pathlib import Path
 
 
@@ -215,6 +217,51 @@ def get_stats(repo_path: Path, old_commit: str, new_commit: str) -> dict:
     return stats
 
 
+def get_installed_version(package: str = "oasr") -> str | None:
+    """Get installed package version."""
+    try:
+        return metadata.version(package)
+    except metadata.PackageNotFoundError:
+        return None
+
+
+def get_latest_pypi_version(package: str = "oasr") -> str | None:
+    """Fetch the latest version from PyPI."""
+    try:
+        with urllib.request.urlopen(f"https://pypi.org/pypi/{package}/json", timeout=5) as response:
+            data = json.load(response)
+            return data.get("info", {}).get("version")
+    except Exception:
+        return None
+
+
+def upgrade_from_pypi(package: str = "oasr") -> tuple[bool, str]:
+    """Upgrade ASR using uv or pip."""
+    commands = [
+        ["uv", "pip", "install", "--upgrade", package],
+        [sys.executable, "-m", "pip", "install", "--upgrade", package],
+    ]
+    last_error = ""
+
+    for cmd in commands:
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=60,
+            )
+            if result.returncode == 0:
+                runner = "uv" if cmd[0] == "uv" else "pip"
+                return True, f"Updated with {runner}"
+            last_error = result.stderr.strip() or result.stdout.strip()
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            last_error = "Update timed out" if isinstance(sys.exc_info()[1], subprocess.TimeoutExpired) else last_error
+            continue
+
+    return False, last_error or "Failed to update with pip"
+
+
 def reinstall_asr(repo_path: Path) -> tuple[bool, str]:
     """Reinstall ASR using uv or pip.
 
@@ -293,10 +340,29 @@ def run(args: argparse.Namespace) -> int:
 
     if not repo_path:
         if args.json:
-            print(json.dumps({"success": False, "error": "Could not find ASR git repository"}))
-        else:
-            print("✗ Could not find ASR git repository", file=sys.stderr)
-            print("  Make sure ASR is installed from git (git clone + pip install -e .)", file=sys.stderr)
+            print(
+                json.dumps(
+                    {
+                        "success": False,
+                        "error": "Could not find ASR git repository",
+                        "hint": "Install from git or use pip to update",
+                    }
+                )
+            )
+            return 1
+
+        print("✗ Could not find ASR git repository", file=sys.stderr)
+        print("  This command updates git installs only.", file=sys.stderr)
+        print("  To update PyPI installs:", file=sys.stderr)
+        print("    pip install --upgrade oasr", file=sys.stderr)
+
+        latest_version = get_latest_pypi_version()
+        installed_version = get_installed_version()
+        if latest_version and installed_version and latest_version != installed_version:
+            print(
+                f"\nUpdate available: {installed_version} → {latest_version}",
+                file=sys.stderr,
+            )
         return 1
 
     if not args.quiet and not args.json:
@@ -306,8 +372,10 @@ def run(args: argparse.Namespace) -> int:
     if not (repo_path / ".git").exists():
         if args.json:
             print(json.dumps({"success": False, "error": "Not a git repository"}))
-        else:
-            print(f"✗ {repo_path} is not a git repository", file=sys.stderr)
+            return 1
+        print(f"✗ {repo_path} is not a git repository", file=sys.stderr)
+        print("  Use pip to update PyPI installs:", file=sys.stderr)
+        print("    pip install --upgrade oasr", file=sys.stderr)
         return 1
 
     # Get remote URL
@@ -348,10 +416,24 @@ def run(args: argparse.Namespace) -> int:
 
     # Check if already up to date
     if message == "already_up_to_date":
+        latest_version = get_latest_pypi_version()
+        installed_version = get_installed_version()
+
         if args.json:
-            print(json.dumps({"success": True, "updated": False, "message": "Already up to date"}))
+            payload = {"success": True, "updated": False, "message": "Already up to date"}
+            if latest_version and installed_version:
+                payload["installed_version"] = installed_version
+                payload["latest_version"] = latest_version
+                payload["pypi_update_available"] = latest_version != installed_version
+            print(json.dumps(payload))
         else:
             print("✓ Already up to date")
+            if latest_version and installed_version and latest_version != installed_version:
+                print(
+                    f"\nPyPI update available: {installed_version} → {latest_version}",
+                    file=sys.stderr,
+                )
+                print("Run: pip install --upgrade oasr", file=sys.stderr)
         return 0
 
     # Get new commit

completions/__init__.py

@@ -0,0 +1 @@
+"""Shell completion scripts for OASR."""