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

cli.py

@@ -13,7 +13,7 @@ from pathlib import Path
 from commands import adapter, clean, clone, config, diff, exec, find, registry, sync, update, use, validate
 from commands import help as help_cmd
 
-__version__ = "0.5.0"
+__version__ = "0.5.2"
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -88,6 +88,11 @@ def create_parser() -> argparse.ArgumentParser:
 
     info_cmd.register(subparsers)
 
+    # Import and register completion command
+    from commands import completion as completion_cmd
+
+    completion_cmd.register_parser(subparsers)
+
     help_cmd.register(subparsers, parser)
 
     return parser

commands/completion.py

@@ -0,0 +1,345 @@
+"""Shell completion management for OASR."""
+
+import os
+import platform
+import sys
+from pathlib import Path
+
+from config import load_config
+
+
+def register_parser(subparsers):
+    """Register the completion subcommand."""
+    parser = subparsers.add_parser(
+        "completion",
+        help="Generate and install shell completions",
+        description="Generate shell completion scripts for bash, zsh, fish, and PowerShell.",
+    )
+
+    parser.add_argument(
+        "shell",
+        nargs="?",
+        choices=["bash", "zsh", "fish", "powershell", "install", "uninstall"],
+        help="Shell type or action (install/uninstall)",
+    )
+
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Force installation even if already installed",
+    )
+
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show what would be done without doing it",
+    )
+
+    parser.set_defaults(func=run)
+
+
+def detect_shell():
+    """
+    Auto-detect the user's shell based on platform and environment.
+
+    Returns:
+        str: Shell name (bash, zsh, fish, powershell)
+    """
+    if platform.system() == "Windows":
+        shell_env = os.environ.get("SHELL", "").lower()
+        if "bash" in shell_env:
+            return "bash"
+        # Check for PowerShell
+        if "PSModulePath" in os.environ or "POWERSHELL" in os.environ.get("SHELL", "").upper():
+            return "powershell"
+        if "zsh" in shell_env:
+            return "zsh"
+        if "fish" in shell_env:
+            return "fish"
+        # Default to PowerShell on Windows
+        return "powershell"
+    else:
+        # Linux/macOS
+        shell = os.environ.get("SHELL", "")
+        if "zsh" in shell:
+            return "zsh"
+        elif "fish" in shell:
+            return "fish"
+        else:
+            # Default to bash on Unix
+            return "bash"
+
+
+def get_completion_script(shell):
+    """
+    Get the completion script content for the specified shell.
+
+    Args:
+        shell: Shell name (bash, zsh, fish, powershell)
+
+    Returns:
+        str: Completion script content
+    """
+    # Map shell names to completion files
+    script_files = {
+        "bash": "bash.sh",
+        "zsh": "zsh.sh",
+        "fish": "fish.fish",
+        "powershell": "powershell.ps1",
+    }
+
+    if shell not in script_files:
+        return ""
+
+    # Get the path to the completion script
+    completion_file = Path(__file__).parent.parent / "completions" / script_files[shell]
+
+    if not completion_file.exists():
+        return f"# {shell} completion script not found"
+
+    return completion_file.read_text()
+
+
+def get_completion_path(shell, system=False):
+    """
+    Get the installation path for completion script.
+
+    Args:
+        shell: Shell name
+        system: If True, use system-wide path (requires root)
+
+    Returns:
+        Path: Installation path
+    """
+    paths = {
+        "bash": {
+            "user": Path.home() / ".bash_completion.d" / "oasr",
+            "system": Path("/etc/bash_completion.d/oasr"),
+        },
+        "zsh": {
+            "user": Path.home() / ".zsh" / "completion" / "_oasr",
+            "system": Path("/usr/local/share/zsh/site-functions/_oasr"),
+        },
+        "fish": {
+            "user": Path.home() / ".config" / "fish" / "completions" / "oasr.fish",
+            "system": Path("/usr/share/fish/vendor_completions.d/oasr.fish"),
+        },
+        "powershell": {
+            "user": Path.home() / ".config" / "powershell" / "oasr_completion.ps1",
+            "system": Path.home() / ".config" / "powershell" / "oasr_completion.ps1",
+        },
+    }
+
+    level = "system" if system else "user"
+    return paths.get(shell, {}).get(level)
+
+
+def print_activation_instructions(shell, path):
+    """
+    Print instructions for activating completions.
+
+    Args:
+        shell: Shell name
+        path: Installation path
+    """
+    instructions = {
+        "bash": f"""
+✓ Completions installed for bash
+
+To activate, add this to your ~/.bashrc:
+    source {path}
+
+Or run:
+    echo 'source {path}' >> ~/.bashrc
+
+Then restart your shell or run:
+    source ~/.bashrc
+""",
+        "zsh": f"""
+✓ Completions installed for zsh
+
+To activate, add this to your ~/.zshrc:
+    fpath=({path.parent} $fpath)
+    autoload -Uz compinit && compinit
+
+Then restart your shell or run:
+    source ~/.zshrc
+""",
+        "fish": f"""
+✓ Completions installed for fish
+
+Completions will be active in new fish shells.
+To activate now, run:
+    source {path}
+""",
+        "powershell": f"""
+✓ Completions installed for PowerShell
+
+To activate, add this to your PowerShell profile ($PROFILE):
+    . {path}
+
+Or run:
+    echo '. {path}' >> $PROFILE
+
+Then restart PowerShell or run:
+    . $PROFILE
+""",
+    }
+
+    print(instructions.get(shell, ""))
+
+
+def is_already_installed(shell):
+    """
+    Check if completions are already installed for the shell.
+
+    Args:
+        shell: Shell name
+
+    Returns:
+        bool: True if already installed
+    """
+    path = get_completion_path(shell)
+    if not path or not path.exists():
+        return False
+
+    # Check for our signature
+    with open(path) as f:
+        content = f.read()
+        return "# oasr completion" in content.lower()
+
+
+def run_output(shell):
+    """
+    Output the completion script to stdout.
+
+    Args:
+        shell: Shell name
+
+    Returns:
+        int: Exit code
+    """
+    script = get_completion_script(shell)
+    print(script)
+    return 0
+
+
+def run_install(args):
+    """
+    Install completion script.
+
+    Args:
+        args: Parsed arguments
+
+    Returns:
+        int: Exit code
+    """
+    shell = args.shell if args.shell != "install" else detect_shell()
+
+    # Check config
+    config = load_config()
+    if not config.get("oasr", {}).get("completions", True):
+        print("Completions are disabled in config (oasr.completions = false)")
+        return 1
+
+    # Check if already installed
+    if is_already_installed(shell) and not args.force:
+        print(f"✓ Completions already installed for {shell}")
+        print("  Use --force to reinstall")
+        return 0
+
+    # Get paths
+    path = get_completion_path(shell)
+    if not path:
+        print(f"Error: Unsupported shell: {shell}", file=sys.stderr)
+        return 1
+
+    # Dry run
+    if args.dry_run:
+        print(f"Would install completion to: {path}")
+        print_activation_instructions(shell, path)
+        return 0
+
+    # Get script
+    script = get_completion_script(shell)
+
+    # Create directory
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Backup existing
+    if path.exists() and not is_already_installed(shell):
+        import time
+
+        backup = path.parent / f"{path.name}.backup.{int(time.time())}"
+        path.rename(backup)
+        print(f"Backed up existing file to: {backup}")
+
+    # Write script
+    path.write_text(script)
+
+    # Success message
+    print_activation_instructions(shell, path)
+
+    return 0
+
+
+def run_uninstall(args):
+    """
+    Uninstall completion script.
+
+    Args:
+        args: Parsed arguments
+
+    Returns:
+        int: Exit code
+    """
+    shell = args.shell if args.shell != "uninstall" else detect_shell()
+
+    path = get_completion_path(shell)
+    if not path or not path.exists():
+        print(f"No completions installed for {shell}")
+        return 0
+
+    # Dry run
+    if args.dry_run:
+        print(f"Would remove: {path}")
+        return 0
+
+    # Remove file
+    path.unlink()
+    print(f"✓ Removed completions for {shell}")
+
+    return 0
+
+
+def run(args):
+    """
+    Execute completion command.
+
+    Args:
+        args: Parsed arguments
+
+    Returns:
+        int: Exit code
+    """
+    # No shell specified - show help
+    if not args.shell:
+        detected = detect_shell()
+        print(f"Detected shell: {detected}")
+        print("\nUsage:")
+        print("  oasr completion bash          # Output bash completion script")
+        print("  oasr completion zsh           # Output zsh completion script")
+        print("  oasr completion fish          # Output fish completion script")
+        print("  oasr completion powershell    # Output PowerShell completion script")
+        print("  oasr completion install       # Auto-detect and install")
+        print("  oasr completion uninstall     # Remove installed completions")
+        return 0
+
+    # Handle actions
+    if args.shell == "install":
+        return run_install(args)
+    elif args.shell == "uninstall":
+        return run_uninstall(args)
+    else:
+        # Output script to stdout
+        return run_output(args.shell)

commands/config.py

@@ -3,8 +3,9 @@
 import argparse
 import sys
 
-from agents import detect_available_agents, get_all_agent_names
+from agents import detect_available_agents
 from config import CONFIG_FILE, load_config, save_config
+from config.schema import validate_agent, validate_profile_reference
 
 
 def register(subparsers: argparse._SubParsersAction) -> None:
@@ -25,6 +26,11 @@ def register(subparsers: argparse._SubParsersAction) -> None:
     )
     set_parser.add_argument("key", help="Configuration key (e.g., 'agent')")
     set_parser.add_argument("value", help="Configuration value")
+    set_parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Skip validation (use carefully)",
+    )
     set_parser.set_defaults(func=run_set)
 
     # config get
@@ -57,40 +63,86 @@ def register(subparsers: argparse._SubParsersAction) -> None:
 
 
 def run_set(args: argparse.Namespace) -> int:
-    """Set a configuration value."""
+    """Set a configuration value with validation."""
     key = args.key.lower()
     value = args.value
+    force = getattr(args, "force", False)
 
-    # Only support agent for now
-    if key == "agent":
-        # Validate agent name
-        valid_agents = get_all_agent_names()
-        if value not in valid_agents:
-            print(
-                f"Error: Invalid agent '{value}'. Must be one of: {', '.join(valid_agents)}",
-                file=sys.stderr,
-            )
+    # 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)
+        return 1
 
-        # Load config, update, save
-        config = load_config(args.config if hasattr(args, "config") else None)
-        config["agent"]["default"] = value
-        save_config(config, args.config if hasattr(args, "config") else None)
+    # 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:
+            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
 
-        # Show available vs configured
-        available = detect_available_agents()
-        if value in available:
-            print(f"✓ Default agent set to: {value}")
+    # Load config
+    config_path = getattr(args, "config", None)
+    config = load_config(config_path=config_path)
+
+    # Validate before setting (unless --force)
+    if not force:
+        # Validate agent
+        if section == "agent" and field == "default":
+            is_valid, error_msg = validate_agent(value)
+            if not is_valid:
+                print(f"Error: {error_msg}", file=sys.stderr)
+                print("\nTo set anyway, use: oasr config set --force agent <name>", file=sys.stderr)
+                return 1
+
+        # Validate profile reference
+        if section == "oasr" and field == "default_profile":
+            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(f"  oasr config set --force oasr.default_profile {value}", file=sys.stderr)
+                return 1
+
+    # Set the value
+    if section not in config:
+        config[section] = {}
+
+    config[section][field] = value
+
+    try:
+        save_config(config, config_path=config_path)
+
+        # Show confirmation
+        if section == "agent" and field == "default":
+            # Special handling for agent - check if available
+            available = detect_available_agents()
+            if value in available:
+                print(f"✓ Default agent set to: {value}")
+            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)
         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,
-            )
+            print(f"✓ Set {section}.{field} = {original_value}")
 
         return 0
-    else:
-        print(f"Error: Unsupported config key '{key}'. Only 'agent' is supported.", file=sys.stderr)
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
         return 1
 
 

commands/exec.py

@@ -101,18 +101,30 @@ def run(args: argparse.Namespace) -> int:
         # Error already printed by _get_user_prompt
         return 1
 
-    # Determine which agent to use
-    agent_name = _get_agent_name(args)
-    if agent_name is None:
-        # Error already printed by _get_agent_name
-        return 1
-
     # === POLICY ENFORCEMENT ===
-    # Load configuration
-    config = load_config()
+    # Build CLI overrides for config loading
+    cli_overrides = {}
+    if args.agent:
+        cli_overrides["agent"] = {"default": args.agent}
+    if args.profile:
+        cli_overrides["oasr"] = cli_overrides.get("oasr", {})
+        cli_overrides["oasr"]["default_profile"] = args.profile
+
+    # Load configuration with precedence: CLI > env > file > defaults
+    config = load_config(cli_overrides=cli_overrides)
 
-    # Determine which profile to use (flag overrides config)
-    profile_name = args.profile if args.profile else config.get("oasr", {}).get("default_profile", "safe")
+    # Determine agent and profile from merged config
+    agent_name = config.get("agent", {}).get("default")
+    profile_name = config.get("oasr", {}).get("default_profile", "safe")
+
+    # Validate agent is set
+    if not agent_name:
+        print(
+            "Error: No agent configured. Set OASR_AGENT, use --agent flag, or run:",
+            file=sys.stderr,
+        )
+        print("  oasr config set agent <name>", file=sys.stderr)
+        return 1
 
     # Load the policy profile
     profile = policy.load(config, profile_name)

completions/__init__.py

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