oasr 0.5.0__py3-none-any.whl

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

@@ -0,0 +1,97 @@
+"""CLI entry point (argparse wiring + dispatch).
+
+Command implementations live under `src/commands/`.
+"""
+
+from __future__ import annotations
+
+import argparse
+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 help as help_cmd
+
+__version__ = "0.5.0"
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Main CLI entry point."""
+    parser = create_parser()
+    args = parser.parse_args(argv)
+
+    if not hasattr(args, "func"):
+        parser.print_help()
+        return 1
+
+    try:
+        return args.func(args)
+    except KeyboardInterrupt:
+        print("\nInterrupted.", file=sys.stderr)
+        return 130
+    except Exception as e:
+        if args.json if hasattr(args, "json") else False:
+            print(json.dumps({"error": str(e)}), file=sys.stderr)
+        else:
+            print(f"Error: {e}", file=sys.stderr)
+        return 3
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """Create the argument parser."""
+    parser = argparse.ArgumentParser(
+        prog="oasr",
+        description="Open Agent Skills Registry - Manage agent skills across IDE integrations.",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    parser.add_argument(
+        "--config",
+        type=Path,
+        help="Override config file path",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output in JSON format",
+    )
+    parser.add_argument(
+        "--quiet",
+        action="store_true",
+        help="Suppress info and warnings",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # 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
+
+    # Deprecated commands
+    use.register(subparsers)  # DEPRECATED - use clone instead
+    find.register(subparsers)
+    validate.register(subparsers)
+    clean.register(subparsers)
+    adapter.register(subparsers)
+    update.register(subparsers)
+
+    # Import and register info command
+    from commands import info as info_cmd
+
+    info_cmd.register(subparsers)
+
+    help_cmd.register(subparsers, parser)
+
+    return parser
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

commands/__init__.py

@@ -0,0 +1,6 @@
+"""Command modules for the ASR CLI.
+
+Each command module exposes:
+- register(subparsers): attach argparse parsers
+- run(args): execute command
+"""

commands/adapter.py

@@ -0,0 +1,102 @@
+"""`asr adapter` command."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from adapters import ClaudeAdapter, CodexAdapter, CopilotAdapter, CursorAdapter, WindsurfAdapter
+from config import load_config
+from registry import load_registry
+
+ADAPTERS = {
+    "cursor": CursorAdapter(),
+    "windsurf": WindsurfAdapter(),
+    "codex": CodexAdapter(),
+    "copilot": CopilotAdapter(),
+    "claude": ClaudeAdapter(),
+}
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser("adapter", help="Generate IDE-specific files")
+    p.add_argument("--exclude", help="Comma-separated skill names to exclude")
+    p.add_argument("--output-dir", type=Path, default=Path("."), help="Output directory")
+    p.add_argument("--copy", action="store_true", help="(Deprecated) Skills are always copied now")
+    p.add_argument("--json", action="store_true", help="Output in JSON format")
+    p.add_argument("--quiet", action="store_true", help="Suppress info/warnings")
+    p.add_argument("--config", type=Path, help="Override config file path")
+
+    adapter_subs = p.add_subparsers(dest="target", help="Target IDE")
+
+    for name in ["cursor", "windsurf", "codex", "copilot", "claude"]:
+        adapter_subs.add_parser(name, help=f"Generate {name} files")
+
+    p.set_defaults(func=run)
+
+
+def run(args: argparse.Namespace) -> int:
+    config = load_config(args.config)
+    entries = load_registry()
+
+    if not entries:
+        if args.json:
+            print(json.dumps({"generated": 0, "error": "no skills registered"}))
+        else:
+            print("No skills registered. Use 'asr add <path>' first.")
+        return 1
+
+    exclude = set()
+    if args.exclude:
+        exclude = set(args.exclude.split(","))
+
+    output_dir = args.output_dir
+
+    if args.target:
+        targets = [args.target]
+    else:
+        targets = config["adapter"]["default_targets"]
+
+    total_generated = 0
+    total_removed = 0
+    results = {}
+
+    for target in targets:
+        if target not in ADAPTERS:
+            if not args.quiet:
+                print(f"Warning: Unknown adapter target: {target}", file=sys.stderr)
+            continue
+
+        adapter = ADAPTERS[target]
+        # Always copy skills now (--copy flag is deprecated but kept for backward compat)
+        generated, removed = adapter.generate_all(entries, output_dir, exclude, copy=True)
+
+        total_generated += len(generated)
+        total_removed += len(removed)
+
+        results[target] = {
+            "generated": len(generated),
+            "removed": len(removed),
+            "output_dir": str(adapter.resolve_output_dir(output_dir)),
+        }
+
+    if args.json:
+        print(
+            json.dumps(
+                {
+                    "total_generated": total_generated,
+                    "total_removed": total_removed,
+                    "targets": results,
+                },
+                indent=2,
+            )
+        )
+    else:
+        for target, info in results.items():
+            print(f"{target}: Generated {info['generated']} file(s) in {info['output_dir']}")
+            if info["removed"]:
+                print(f"  Removed {info['removed']} stale file(s)")
+
+    return 0