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

adapters/base.py

@@ -105,15 +105,15 @@ class BaseAdapter(ABC):
             Path to the copied skill directory.
         """
         dest = skills_dir / skill.name
-        
+
         # Get the skill's content hash from manifest for tracking
         # If manifest doesn't exist, skip tracking (graceful degradation)
         inject_tracking = False
         source_hash = None
-        
+
         try:
             from manifest import load_manifest
-            
+
             manifest = load_manifest(skill.name)
             if manifest:
                 source_hash = manifest.content_hash
@@ -121,7 +121,7 @@ class BaseAdapter(ABC):
         except Exception:
             # Gracefully skip tracking if manifest cannot be loaded
             pass
-        
+
         return copy_skill_unified(
             skill.path,
             dest,

agents/__init__.py

@@ -0,0 +1,25 @@
+"""Agent driver system."""
+
+from agents.base import AgentDriver
+from agents.claude import ClaudeDriver
+from agents.codex import CodexDriver
+from agents.copilot import CopilotDriver
+from agents.opencode import OpenCodeDriver
+from agents.registry import (
+    DRIVERS,
+    detect_available_agents,
+    get_all_agent_names,
+    get_driver,
+)
+
+__all__ = [
+    "AgentDriver",
+    "CodexDriver",
+    "CopilotDriver",
+    "ClaudeDriver",
+    "OpenCodeDriver",
+    "DRIVERS",
+    "get_driver",
+    "detect_available_agents",
+    "get_all_agent_names",
+]

agents/base.py

@@ -0,0 +1,96 @@
+"""Abstract base class for agent drivers."""
+
+import shutil
+import subprocess
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+
+class AgentDriver(ABC):
+    """Abstract base class for AI agent CLI drivers."""
+
+    @abstractmethod
+    def get_name(self) -> str:
+        """Get the agent name.
+
+        Returns:
+            Agent name (e.g., 'codex', 'copilot', 'claude').
+        """
+
+    @abstractmethod
+    def get_binary_name(self) -> str:
+        """Get the CLI binary name to check for.
+
+        Returns:
+            Binary name (e.g., 'codex', 'copilot', 'claude').
+        """
+
+    def detect(self) -> bool:
+        """Check if the agent binary is available in PATH.
+
+        Returns:
+            True if binary is found, False otherwise.
+        """
+        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]:
+        """Build the command to execute.
+
+        Args:
+            skill_content: Full SKILL.md content.
+            user_prompt: User's prompt/request.
+            cwd: Current working directory.
+
+        Returns:
+            Command as list of strings (for subprocess).
+        """
+
+    def execute(self, skill_content: str, user_prompt: str, cwd: Path | 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).
+
+        Returns:
+            CompletedProcess with stdout/stderr/returncode.
+
+        Raises:
+            FileNotFoundError: If agent binary not found.
+        """
+        if not self.detect():
+            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)
+
+        return subprocess.run(
+            cmd,
+            cwd=working_dir,
+            capture_output=False,  # Stream to stdout/stderr
+            text=True,
+        )
+
+    def format_injected_prompt(self, skill_content: str, user_prompt: str, cwd: Path) -> str:
+        """Format the injected prompt with skill content.
+
+        Args:
+            skill_content: Full SKILL.md content.
+            user_prompt: User's prompt/request.
+            cwd: Current working directory.
+
+        Returns:
+            Formatted prompt string.
+        """
+        return f"""You are executing a skill. Follow these instructions carefully:
+
+━━━━━━━━ SKILL INSTRUCTIONS ━━━━━━━━
+{skill_content}
+━━━━━━━━ END SKILL ━━━━━━━━
+
+USER REQUEST: {user_prompt}
+
+Working directory: {cwd}
+Execute the skill above for this request."""

agents/claude.py

@@ -0,0 +1,25 @@
+"""Claude CLI agent driver."""
+
+from pathlib import Path
+
+from agents.base import AgentDriver
+
+
+class ClaudeDriver(AgentDriver):
+    """Driver for Claude CLI agent."""
+
+    def get_name(self) -> str:
+        """Get the agent name."""
+        return "claude"
+
+    def get_binary_name(self) -> str:
+        """Get the CLI binary name."""
+        return "claude"
+
+    def build_command(self, skill_content: str, user_prompt: str, cwd: Path) -> 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"]

agents/codex.py

@@ -0,0 +1,25 @@
+"""Codex agent driver."""
+
+from pathlib import Path
+
+from agents.base import AgentDriver
+
+
+class CodexDriver(AgentDriver):
+    """Driver for Codex CLI agent."""
+
+    def get_name(self) -> str:
+        """Get the agent name."""
+        return "codex"
+
+    def get_binary_name(self) -> str:
+        """Get the CLI binary name."""
+        return "codex"
+
+    def build_command(self, skill_content: str, user_prompt: str, cwd: Path) -> 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]

agents/copilot.py

@@ -0,0 +1,25 @@
+"""GitHub Copilot agent driver."""
+
+from pathlib import Path
+
+from agents.base import AgentDriver
+
+
+class CopilotDriver(AgentDriver):
+    """Driver for GitHub Copilot CLI agent."""
+
+    def get_name(self) -> str:
+        """Get the agent name."""
+        return "copilot"
+
+    def get_binary_name(self) -> str:
+        """Get the CLI binary name."""
+        return "copilot"
+
+    def build_command(self, skill_content: str, user_prompt: str, cwd: Path) -> 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]

agents/opencode.py

@@ -0,0 +1,25 @@
+"""OpenCode CLI agent driver."""
+
+from pathlib import Path
+
+from agents.base import AgentDriver
+
+
+class OpenCodeDriver(AgentDriver):
+    """Driver for OpenCode CLI agent."""
+
+    def get_name(self) -> str:
+        """Get the agent name."""
+        return "opencode"
+
+    def get_binary_name(self) -> str:
+        """Get the CLI binary name."""
+        return "opencode"
+
+    def build_command(self, skill_content: str, user_prompt: str, cwd: Path) -> 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]

agents/registry.py

@@ -0,0 +1,57 @@
+"""Agent driver registry and factory."""
+
+from agents.base import AgentDriver
+from agents.claude import ClaudeDriver
+from agents.codex import CodexDriver
+from agents.copilot import CopilotDriver
+from agents.opencode import OpenCodeDriver
+
+# Registry of all available drivers
+DRIVERS: dict[str, type[AgentDriver]] = {
+    "codex": CodexDriver,
+    "copilot": CopilotDriver,
+    "claude": ClaudeDriver,
+    "opencode": OpenCodeDriver,
+}
+
+
+def get_driver(agent_name: str) -> AgentDriver:
+    """Get driver instance by agent name.
+
+    Args:
+        agent_name: Name of agent (codex, copilot, claude).
+
+    Returns:
+        AgentDriver instance.
+
+    Raises:
+        ValueError: If agent name is invalid.
+    """
+    if agent_name not in DRIVERS:
+        valid = ", ".join(sorted(DRIVERS.keys()))
+        raise ValueError(f"Invalid agent '{agent_name}'. Must be one of: {valid}")
+
+    return DRIVERS[agent_name]()
+
+
+def detect_available_agents() -> list[str]:
+    """Detect which agent binaries are available in PATH.
+
+    Returns:
+        List of available agent names.
+    """
+    available = []
+    for name, driver_class in DRIVERS.items():
+        driver = driver_class()
+        if driver.detect():
+            available.append(name)
+    return sorted(available)
+
+
+def get_all_agent_names() -> list[str]:
+    """Get all supported agent names.
+
+    Returns:
+        List of all agent names.
+    """
+    return sorted(DRIVERS.keys())

cli.py

@@ -10,10 +10,10 @@ import json
 import sys
 from pathlib import Path
 
-from commands import adapter, clean, diff, find, registry, sync, update, use, validate
+from commands import adapter, clean, clone, config, diff, exec, find, registry, sync, update, use, validate
 from commands import help as help_cmd
 
-__version__ = "0.3.4"
+__version__ = "0.4.1"
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -67,13 +67,16 @@ def create_parser() -> argparse.ArgumentParser:
 
     subparsers = parser.add_subparsers(dest="command", help="Available commands")
 
-    # New taxonomy (v0.3.0)
+    # New taxonomy (v0.3.0+)
     registry.register(subparsers)  # Registry operations (add, rm, sync, list)
     diff.register(subparsers)  # Show tracked skill status
     sync.register(subparsers)  # Refresh tracked skills
+    config.register(subparsers)  # Configuration management
+    clone.register(subparsers)  # Clone skills to directory
+    exec.register(subparsers)  # Execute skills with agent CLI
 
-    # Unchanged commands
-    use.register(subparsers)
+    # Deprecated commands
+    use.register(subparsers)  # DEPRECATED - use clone instead
     find.register(subparsers)
     validate.register(subparsers)
     clean.register(subparsers)

commands/add.py

@@ -139,9 +139,56 @@ def run(args: argparse.Namespace) -> int:
 
             temp_dir = fetch_remote_to_temp(url)
 
+            # Check for multiple skills in the repo
+            skill_dirs = _find_skill_dirs(temp_dir)
+
+            if len(skill_dirs) > 1:
+                # Multiple skills found
+                if not args.quiet and not args.json:
+                    print(f"✓ Found {len(skill_dirs)} skills in repository:", file=sys.stderr)
+                    for skill_dir in skill_dirs:
+                        rel_path = skill_dir.relative_to(temp_dir)
+                        print(f"    - {rel_path}", file=sys.stderr)
+                    print(file=sys.stderr)
+
+                    # Prompt user
+                    response = input("Add all skills? [Y/n]: ").strip().lower()
+                    if response and response not in ("y", "yes"):
+                        skipped_count += len(skill_dirs)
+                        for skill_dir in skill_dirs:
+                            rel_path = skill_dir.relative_to(temp_dir)
+                            results.append(
+                                {"url": url, "skill": str(rel_path), "added": False, "reason": "user declined"}
+                            )
+                        continue
+
+                # Add all skills
+                for skill_dir in skill_dirs:
+                    rel_path = skill_dir.relative_to(temp_dir)
+                    skill_url = f"{url}/{rel_path}" if str(rel_path) != "." else url
+
+                    result = _add_single_remote_skill(
+                        skill_dir,
+                        skill_url,
+                        url,  # repo_root
+                        args,
+                        max_lines,
+                        results,
+                    )
+
+                    if result["added"]:
+                        added_count += 1
+                    else:
+                        skipped_count += 1
+
+                continue  # Skip single-skill handling
+
+            # Single skill handling (original logic)
+            skill_dir = skill_dirs[0] if skill_dirs else temp_dir
+
             if not args.quiet and not args.json:
                 # Count files validated
-                file_count = sum(1 for _ in temp_dir.rglob("*") if _.is_file())
+                file_count = sum(1 for _ in skill_dir.rglob("*") if _.is_file())
                 print(f"✓ Validated {file_count} file(s)", file=sys.stderr)
         except Exception as e:
             skipped_count += 1
@@ -152,8 +199,8 @@ def run(args: argparse.Namespace) -> int:
             continue
 
         try:
-            # Validate fetched content (skip name match for temp directory)
-            result = validate_skill(temp_dir, reference_max_lines=max_lines, skip_name_match=True)
+            # Validate fetched content
+            result = validate_skill(skill_dir, reference_max_lines=max_lines, skip_name_match=True)
             if not args.quiet and not args.json:
                 _print_validation_result(result)
                 print()
@@ -171,7 +218,7 @@ def run(args: argparse.Namespace) -> int:
                 continue
 
             # Discover skill info from fetched content
-            discovered = discover_single(temp_dir)
+            discovered = discover_single(skill_dir)
             if not discovered:
                 skipped_count += 1
                 results.append({"url": url, "added": False, "reason": "could not discover skill info"})
@@ -300,3 +347,89 @@ def _run_recursive(args: argparse.Namespace, root: Path, max_lines: int) -> int:
         print(f"\n{added_count} skill(s) added, {skipped_count} skipped")
 
     return 0
+
+
+def _find_skill_dirs(root: Path) -> list[Path]:
+    """Find all directories containing SKILL.md files.
+
+    Args:
+        root: Root directory to search.
+
+    Returns:
+        List of directories containing SKILL.md (sorted by depth, then name).
+    """
+    skill_dirs = []
+
+    for skill_md in root.rglob("SKILL.md"):
+        skill_dir = skill_md.parent
+        skill_dirs.append(skill_dir)
+
+    # Sort by depth (shallowest first), then alphabetically
+    skill_dirs.sort(key=lambda p: (len(p.relative_to(root).parts), str(p)))
+
+    return skill_dirs
+
+
+def _add_single_remote_skill(
+    skill_dir: Path,
+    skill_url: str,
+    repo_root_url: str,
+    args: argparse.Namespace,
+    max_lines: int,
+    results: list[dict],
+) -> dict:
+    """Add a single remote skill.
+
+    Args:
+        skill_dir: Local path to skill directory (in temp).
+        skill_url: Full URL to this specific skill.
+        repo_root_url: URL to repository root.
+        args: Command arguments.
+        max_lines: Max reference lines for validation.
+        results: Results list to append to.
+
+    Returns:
+        Result dictionary with 'added' status.
+    """
+    # Validate skill
+    result = validate_skill(skill_dir, reference_max_lines=max_lines, skip_name_match=True)
+
+    if not result.valid:
+        res = {"url": skill_url, "added": False, "reason": "validation errors"}
+        results.append(res)
+        if not args.quiet and not args.json:
+            print(f"⚠ Skipping {skill_dir.name}: validation errors", file=sys.stderr)
+        return res
+
+    if args.strict and result.warnings:
+        res = {"url": skill_url, "added": False, "reason": "validation warnings (strict mode)"}
+        results.append(res)
+        if not args.quiet and not args.json:
+            print(f"⚠ Skipping {skill_dir.name}: validation warnings (strict)", file=sys.stderr)
+        return res
+
+    # Discover skill info
+    discovered = discover_single(skill_dir)
+    if not discovered:
+        res = {"url": skill_url, "added": False, "reason": "could not discover skill info"}
+        results.append(res)
+        if not args.quiet and not args.json:
+            print(f"⚠ Skipping {skill_dir.name}: could not discover skill info", file=sys.stderr)
+        return res
+
+    # Create entry with skill-specific URL
+    entry = SkillEntry(
+        path=skill_url,  # Full path to this skill
+        name=discovered.name,
+        description=discovered.description,
+    )
+
+    is_new = add_skill(entry)
+    res = {"name": entry.name, "url": skill_url, "added": True, "new": is_new}
+    results.append(res)
+
+    if not args.quiet and not args.json:
+        action = "Added" if is_new else "Updated"
+        print(f"{action} skill: {entry.name}", file=sys.stderr)
+
+    return res

commands/clone.py

@@ -0,0 +1,178 @@
+"""`oasr clone` command - copy skill(s) to target directory."""
+
+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
+
+
+def register(subparsers) -> None:
+    """Register the clone command."""
+    p = subparsers.add_parser(
+        "clone",
+        help="Clone skill(s) to target directory",
+        description="Clone skills from the registry to a target directory with tracking metadata",
+    )
+    p.add_argument("names", nargs="+", help="Skill name(s) or glob pattern(s) to clone")
+    p.add_argument(
+        "-d",
+        "--dir",
+        type=Path,
+        default=Path("."),
+        dest="output_dir",
+        help="Target directory (default: current)",
+    )
+    p.add_argument("--json", action="store_true", help="Output in JSON format")
+    p.add_argument("--quiet", action="store_true", help="Suppress info/warnings")
+    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:
+    """Execute the clone command."""
+    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 clone {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 clone {name}: {e}")
+
+    if not args.quiet:
+        for w in warnings:
+            print(f"⚠ {w}", file=sys.stderr)
+
+    if args.json:
+        print(
+            json.dumps(
+                {
+                    "copied": len(copied),
+                    "warnings": len(warnings),
+                    "skills": copied,
+                },
+                indent=2,
+            )
+        )
+    else:
+        for c in copied:
+            print(f"Cloned: {c['name']} → {c['dest']}")
+        if copied:
+            print(f"\n{len(copied)} skill(s) cloned to {output_dir}")
+
+    return 1 if warnings and not copied else 0