oasr 0.3.4__py3-none-any.whl → 0.4.1__py3-none-any.whl

commands/config.py

@@ -0,0 +1,163 @@
+"""Config command - manage OASR configuration."""
+
+import argparse
+import sys
+
+from agents import detect_available_agents, get_all_agent_names
+from config import CONFIG_FILE, load_config, save_config
+
+
+def register(subparsers: argparse._SubParsersAction) -> None:
+    """Register the config command."""
+    parser = subparsers.add_parser(
+        "config",
+        help="Manage configuration",
+        description="Manage OASR configuration settings",
+    )
+
+    config_subparsers = parser.add_subparsers(dest="config_action", help="Config actions")
+
+    # config set
+    set_parser = config_subparsers.add_parser(
+        "set",
+        help="Set a configuration value",
+        description="Set a configuration value",
+    )
+    set_parser.add_argument("key", help="Configuration key (e.g., 'agent')")
+    set_parser.add_argument("value", help="Configuration value")
+    set_parser.set_defaults(func=run_set)
+
+    # config get
+    get_parser = config_subparsers.add_parser(
+        "get",
+        help="Get a configuration value",
+        description="Get a configuration value",
+    )
+    get_parser.add_argument("key", help="Configuration key (e.g., 'agent')")
+    get_parser.set_defaults(func=run_get)
+
+    # config list
+    list_parser = config_subparsers.add_parser(
+        "list",
+        help="List all configuration",
+        description="List all configuration settings",
+    )
+    list_parser.set_defaults(func=run_list)
+
+    # config path
+    path_parser = config_subparsers.add_parser(
+        "path",
+        help="Show config file path",
+        description="Show configuration file path",
+    )
+    path_parser.set_defaults(func=run_path)
+
+    # Default to showing help if no subcommand
+    parser.set_defaults(func=lambda args: parser.print_help() or 1)
+
+
+def run_set(args: argparse.Namespace) -> int:
+    """Set a configuration value."""
+    key = args.key.lower()
+    value = args.value
+
+    # 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,
+            )
+            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)
+
+        # Show available vs configured
+        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,
+            )
+
+        return 0
+    else:
+        print(f"Error: Unsupported config key '{key}'. Only 'agent' is supported.", file=sys.stderr)
+        return 1
+
+
+def run_get(args: argparse.Namespace) -> int:
+    """Get a configuration value."""
+    key = args.key.lower()
+
+    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)
+        return 1
+
+
+def run_list(args: argparse.Namespace) -> int:
+    """List all configuration."""
+    config = load_config(args.config if hasattr(args, "config") else None)
+
+    print("Configuration:")
+    print()
+
+    # Agent section
+    print("  [agent]")
+    agent = config["agent"].get("default")
+    if agent:
+        available = detect_available_agents()
+        status = "✓" if agent in available else "✗"
+        print(f"    default = {agent} {status}")
+    else:
+        print("    default = (not set)")
+    print()
+
+    # Show available agents
+    available = detect_available_agents()
+    if available:
+        print(f"  Available agents: {', '.join(available)}")
+    else:
+        print("  Available agents: (none detected)")
+    print()
+
+    # Validation section
+    print("  [validation]")
+    print(f"    reference_max_lines = {config['validation']['reference_max_lines']}")
+    print(f"    strict = {config['validation']['strict']}")
+    print()
+
+    # Adapter section
+    print("  [adapter]")
+    print(f"    default_targets = {config['adapter']['default_targets']}")
+    print()
+
+    return 0
+
+
+def run_path(args: argparse.Namespace) -> int:
+    """Show config file path."""
+    if hasattr(args, "config") and args.config:
+        config_path = args.config
+    else:
+        config_path = CONFIG_FILE
+    print(config_path)
+    return 0

commands/exec.py

@@ -0,0 +1,199 @@
+"""Execute a skill from the registry using an agent CLI."""
+
+import argparse
+import sys
+from pathlib import Path
+
+from agents.registry import detect_available_agents, get_driver
+from config import load_config
+from registry import load_registry
+
+
+def register(subparsers):
+    """Register the exec command."""
+    setup_parser(subparsers)
+
+
+def setup_parser(subparsers):
+    """Set up the exec command parser."""
+    parser = subparsers.add_parser(
+        "exec",
+        help="Execute a skill from the registry",
+        description="Execute a skill from the registry using an agent CLI. "
+        "The skill is executed in the current working directory.",
+    )
+    parser.add_argument(
+        "skill_name",
+        help="Name of the skill to execute from the registry",
+    )
+    parser.add_argument(
+        "-p",
+        "--prompt",
+        help="Inline prompt/instructions for the agent",
+    )
+    parser.add_argument(
+        "-i",
+        "--instructions",
+        metavar="FILE",
+        help="Read prompt/instructions from a file",
+    )
+    parser.add_argument(
+        "-a",
+        "--agent",
+        help="Override the default agent (codex, copilot, claude, opencode)",
+    )
+    parser.set_defaults(func=run)
+
+
+def run(args: argparse.Namespace) -> int:
+    """Execute a skill from the registry."""
+    # Load registry to find the skill
+    entries = load_registry()
+    entry_map = {e.name: e for e in entries}
+    skill_name = args.skill_name
+
+    if skill_name not in entry_map:
+        print(f"Error: Skill '{skill_name}' not found in registry", file=sys.stderr)
+        print("\nUse 'oasr registry list' to see available skills.", file=sys.stderr)
+        return 1
+
+    skill_entry = entry_map[skill_name]
+    skill_source = skill_entry.path
+
+    if not skill_source:
+        print(f"Error: Skill '{skill_name}' has no source configured", file=sys.stderr)
+        return 1
+
+    # Get the skill content - look for SKILL.md in the skill directory
+    skill_dir = Path(skill_source)
+    skill_path = skill_dir / "SKILL.md"
+
+    if not skill_path.exists():
+        print(f"Error: Skill file not found: {skill_path}", file=sys.stderr)
+        print("\nTry running 'oasr sync' to update your skills.", file=sys.stderr)
+        return 1
+
+    try:
+        skill_content = skill_path.read_text(encoding="utf-8")
+    except Exception as e:
+        print(f"Error reading skill file: {e}", file=sys.stderr)
+        return 1
+
+    # Get the user prompt from various sources
+    user_prompt = _get_user_prompt(args)
+    if user_prompt is None:
+        # 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
+
+    # Get the agent driver
+    try:
+        driver = get_driver(agent_name)
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+    # Execute the skill
+    print(f"Executing skill '{skill_name}' with {agent_name}...", file=sys.stderr)
+    print("━" * 60, file=sys.stderr)
+
+    try:
+        result = driver.execute(skill_content, user_prompt)
+        # CompletedProcess has returncode attribute (0 = success)
+        # Output was already streamed to stdout since capture_output=False
+        return result.returncode
+    except Exception as e:
+        print(f"\nUnexpected error: {e}", file=sys.stderr)
+        return 1
+
+
+def _get_user_prompt(args: argparse.Namespace) -> str | None:
+    """Get the user prompt from CLI args or stdin.
+
+    Returns None if there's an error, with error message printed to stderr.
+    """
+    # Check for conflicting options
+    if args.prompt and args.instructions:
+        print(
+            "Error: Cannot use both --prompt and --instructions at the same time",
+            file=sys.stderr,
+        )
+        return None
+
+    # Option 1: Inline prompt via -p/--prompt
+    if args.prompt:
+        return args.prompt
+
+    # Option 2: File-based instructions via -i/--instructions
+    if args.instructions:
+        instructions_path = Path(args.instructions)
+        if not instructions_path.exists():
+            print(f"Error: Instructions file not found: {args.instructions}", file=sys.stderr)
+            return None
+
+        try:
+            return instructions_path.read_text(encoding="utf-8")
+        except Exception as e:
+            print(f"Error reading instructions file: {e}", file=sys.stderr)
+            return None
+
+    # Option 3: Read from stdin
+    if not sys.stdin.isatty():
+        try:
+            return sys.stdin.read()
+        except Exception as e:
+            print(f"Error reading from stdin: {e}", file=sys.stderr)
+            return None
+
+    # No prompt provided
+    print("Error: No prompt provided", file=sys.stderr)
+    print("\nProvide a prompt using one of:", file=sys.stderr)
+    print("  -p/--prompt 'Your prompt here'", file=sys.stderr)
+    print("  -i/--instructions path/to/file.txt", file=sys.stderr)
+    print("  echo 'Your prompt' | oasr exec <skill>", file=sys.stderr)
+    return None
+
+
+def _get_agent_name(args: argparse.Namespace) -> str | None:
+    """Get the agent name from CLI flag or config.
+
+    Returns None if there's an error, with error message printed to stderr.
+    """
+    # Option 1: Explicit --agent flag
+    if args.agent:
+        agent_name = args.agent.lower()
+        # Validate it's a known and available agent
+        available = detect_available_agents()
+        if agent_name not in available or not available[agent_name]:
+            print(f"Error: Agent '{agent_name}' is not available", file=sys.stderr)
+            print("\nAvailable agents:", file=sys.stderr)
+            for name in sorted(available.keys()):
+                status = "✓" if available[name] else "✗"
+                print(f"  {status} {name}", file=sys.stderr)
+            return None
+        return agent_name
+
+    # Option 2: Default from config
+    config = load_config()
+    default_agent = config.get("agent", {}).get("default")
+
+    if default_agent:
+        return default_agent
+
+    # No agent configured
+    print("Error: No agent configured", file=sys.stderr)
+    print("\nConfigure a default agent with:", file=sys.stderr)
+    print("  oasr config set agent <agent-name>", file=sys.stderr)
+    print("\nOr specify an agent for this command:", file=sys.stderr)
+    print("  oasr exec --agent <agent-name> <skill>", file=sys.stderr)
+    print("\nAvailable agents:", file=sys.stderr)
+    available = detect_available_agents()
+    for name in sorted(available.keys()):
+        status = "✓" if available[name] else "✗"
+        print(f"  {status} {name}", file=sys.stderr)
+    return None

commands/use.py

@@ -1,19 +1,21 @@
-"""`asr use` command."""
+"""`asr use` command - DEPRECATED, use `oasr clone` instead."""
 
 from __future__ import annotations
 
 import argparse
-import fnmatch
-import json
 import sys
 from pathlib import Path
 
-from registry import load_registry
-from skillcopy import copy_skill
+from commands import clone
 
 
 def register(subparsers) -> None:
-    p = subparsers.add_parser("use", help="Copy skill(s) to target directory")
+    """Register the deprecated use command."""
+    p = subparsers.add_parser(
+        "use",
+        help="[DEPRECATED] Copy skill(s) - use 'clone' instead",
+        description="DEPRECATED: Use 'oasr clone' instead. This command will be removed in v0.5.0.",
+    )
     p.add_argument("names", nargs="+", help="Skill name(s) or glob pattern(s) to copy")
     p.add_argument(
         "-d",
@@ -28,145 +30,16 @@ def register(subparsers) -> None:
     p.set_defaults(func=run)
 
 
-def _match_skills(patterns: list[str], entry_map: dict) -> tuple[list[str], list[str]]:
-    """Match skill names against patterns (exact or glob).
-
-    Returns:
-        Tuple of (matched_names, unmatched_patterns).
-    """
-    matched = set()
-    unmatched = []
-    all_names = list(entry_map.keys())
-
-    for pattern in patterns:
-        if pattern in entry_map:
-            matched.add(pattern)
-        elif any(c in pattern for c in "*?["):
-            # Glob pattern
-            matches = fnmatch.filter(all_names, pattern)
-            if matches:
-                matched.update(matches)
-            else:
-                unmatched.append(pattern)
-        else:
-            unmatched.append(pattern)
-
-    return list(matched), unmatched
-
-
 def run(args: argparse.Namespace) -> int:
-    entries = load_registry()
-    entry_map = {e.name: e for e in entries}
-
-    output_dir = args.output_dir.resolve()
-    output_dir.mkdir(parents=True, exist_ok=True)
-
-    copied = []
-    warnings = []
-
-    matched_names, unmatched = _match_skills(args.names, entry_map)
-
-    for pattern in unmatched:
-        warnings.append(f"No skills matched: {pattern}")
-
-    # Get manifests for tracking metadata
-    from manifest import load_manifest
-
-    # Separate remote and local skills for parallel processing
-    from skillcopy.remote import is_remote_source
-
-    remote_names = [name for name in matched_names if is_remote_source(entry_map[name].path)]
-    local_names = [name for name in matched_names if not is_remote_source(entry_map[name].path)]
-
-    # Handle remote skills with parallel fetching
-    if remote_names:
-        print(f"Fetching {len(remote_names)} remote skill(s)...", file=sys.stderr)
-        import threading
-        from concurrent.futures import ThreadPoolExecutor, as_completed
-
-        print_lock = threading.Lock()
-
-        def copy_remote_entry(name):
-            """Copy a remote skill with thread-safe progress."""
-            entry = entry_map[name]
-            dest = output_dir / name
-
-            try:
-                with print_lock:
-                    platform = (
-                        "GitHub" if "github.com" in entry.path else "GitLab" if "gitlab.com" in entry.path else "remote"
-                    )
-                    print(f"  ↓ {name} (fetching from {platform}...)", file=sys.stderr, flush=True)
-
-                # Get manifest hash for tracking
-                manifest = load_manifest(name)
-                source_hash = manifest.content_hash if manifest else None
-
-                copy_skill(
-                    entry.path,
-                    dest,
-                    validate=False,
-                    show_progress=False,
-                    skill_name=name,
-                    inject_tracking=True,
-                    source_hash=source_hash,
-                )
-
-                with print_lock:
-                    print(f"  ✓ {name} (downloaded)", file=sys.stderr)
-
-                return {"name": name, "src": entry.path, "dest": str(dest)}, None
-            except Exception as e:
-                with print_lock:
-                    print(f"  ✗ {name} ({str(e)[:50]}...)", file=sys.stderr)
-                return None, f"Failed to copy {name}: {e}"
-
-        # Copy remote skills in parallel
-        with ThreadPoolExecutor(max_workers=4) as executor:
-            futures = {executor.submit(copy_remote_entry, name): name for name in remote_names}
-
-            for future in as_completed(futures):
-                result, error = future.result()
-                if result:
-                    copied.append(result)
-                if error:
-                    warnings.append(error)
-
-    # Handle local skills sequentially (fast anyway)
-    for name in sorted(local_names):
-        entry = entry_map[name]
-        dest = output_dir / name
-
-        try:
-            # Get manifest hash for tracking
-            manifest = load_manifest(name)
-            source_hash = manifest.content_hash if manifest else None
-
-            # Unified copy with tracking
-            copy_skill(entry.path, dest, validate=False, inject_tracking=True, source_hash=source_hash)
-            copied.append({"name": name, "src": entry.path, "dest": str(dest)})
-        except Exception as e:
-            warnings.append(f"Failed to copy {name}: {e}")
-
-    if not args.quiet:
-        for w in warnings:
-            print(f"⚠ {w}", file=sys.stderr)
-
-    if args.json:
+    """Execute the deprecated use command (delegates to clone)."""
+    # Show deprecation warning unless --quiet or --json
+    if not args.quiet and not args.json:
         print(
-            json.dumps(
-                {
-                    "copied": len(copied),
-                    "warnings": len(warnings),
-                    "skills": copied,
-                },
-                indent=2,
-            )
+            "⚠ Warning: 'oasr use' is deprecated. Use 'oasr clone' instead.",
+            file=sys.stderr,
         )
-    else:
-        for c in copied:
-            print(f"Copied: {c['name']} → {c['dest']}")
-        if copied:
-            print(f"\n{len(copied)} skill(s) copied to {output_dir}")
+        print("  This command will be removed in v0.5.0.", file=sys.stderr)
+        print(file=sys.stderr)
 
-    return 1 if warnings and not copied else 0
+    # Delegate to clone command
+    return clone.run(args)

config.py → config/__init__.py

@@ -11,18 +11,21 @@ else:
 
 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"
 
-DEFAULT_CONFIG: dict[str, Any] = {
-    "validation": {
-        "reference_max_lines": 500,
-        "strict": False,
-    },
-    "adapter": {
-        "default_targets": ["cursor", "windsurf"],
-    },
-}
+__all__ = [
+    "OASR_DIR",
+    "CONFIG_FILE",
+    "ensure_oasr_dir",
+    "ensure_skills_dir",
+    "load_config",
+    "save_config",
+    "get_default_config",
+]
 
 
 def ensure_oasr_dir() -> Path:
@@ -48,9 +51,12 @@ def load_config(config_path: Path | None = None) -> dict[str, Any]:
     """
     path = config_path or CONFIG_FILE
 
-    config = DEFAULT_CONFIG.copy()
-    config["validation"] = DEFAULT_CONFIG["validation"].copy()
-    config["adapter"] = DEFAULT_CONFIG["adapter"].copy()
+    # Deep copy defaults
+    config = {
+        "validation": DEFAULT_CONFIG["validation"].copy(),
+        "adapter": DEFAULT_CONFIG["adapter"].copy(),
+        "agent": DEFAULT_CONFIG["agent"].copy(),
+    }
 
     if path.exists():
         with open(path, "rb") as f:
@@ -60,6 +66,8 @@ def load_config(config_path: Path | None = None) -> dict[str, Any]:
             config["validation"].update(loaded["validation"])
         if "adapter" in loaded:
             config["adapter"].update(loaded["adapter"])
+        if "agent" in loaded:
+            config["agent"].update(loaded["agent"])
 
     return config
 
@@ -70,17 +78,32 @@ def save_config(config: dict[str, Any], config_path: Path | None = None) -> None
     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, f)
+        tomli_w.dump(config_to_save, f)
 
 
 def get_default_config() -> dict[str, Any]:
     """Return a copy of the default configuration."""
-    config = DEFAULT_CONFIG.copy()
-    config["validation"] = DEFAULT_CONFIG["validation"].copy()
-    config["adapter"] = DEFAULT_CONFIG["adapter"].copy()
-    return config
+    return {
+        "validation": DEFAULT_CONFIG["validation"].copy(),
+        "adapter": DEFAULT_CONFIG["adapter"].copy(),
+        "agent": DEFAULT_CONFIG["agent"].copy(),
+    }

config/defaults.py

@@ -0,0 +1,16 @@
+"""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,
+    },
+}

config/schema.py

@@ -0,0 +1,36 @@
+"""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")