oasr 0.5.0__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/diff.py

@@ -0,0 +1,180 @@
+"""`oasr diff` command - show tracked skill status."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from manifest import load_manifest
+from tracking import extract_metadata
+
+
+def register(subparsers) -> None:
+    """Register the diff command."""
+    p = subparsers.add_parser("diff", help="Show status of tracked skills (copied with metadata)")
+    p.add_argument(
+        "path",
+        nargs="?",
+        type=Path,
+        default=Path.cwd(),
+        help="Path to scan for tracked skills (default: current directory)",
+    )
+    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 run(args: argparse.Namespace) -> int:
+    """Show status of tracked skills in the given path."""
+    scan_path = args.path.resolve()
+
+    if not scan_path.exists():
+        print(f"Error: Path does not exist: {scan_path}", file=sys.stderr)
+        return 1
+
+    # Find all SKILL.md files recursively
+    if not args.quiet and not args.json:
+        print(f"Scanning {scan_path} for tracked skills...", file=sys.stderr)
+
+    tracked_skills = []
+    skill_md_files = list(scan_path.rglob("SKILL.md"))
+
+    for skill_md in skill_md_files:
+        skill_dir = skill_md.parent
+        metadata = extract_metadata(skill_dir)
+
+        if metadata:
+            tracked_skills.append((skill_dir, metadata))
+
+    if not tracked_skills:
+        if args.json:
+            print(json.dumps({"tracked": 0, "skills": []}))
+        else:
+            print("No tracked skills found.")
+        return 0
+
+    # Determine status for each tracked skill
+    results = []
+    up_to_date = 0
+    outdated = 0
+    modified = 0
+    untracked = 0
+
+    for skill_dir, metadata in tracked_skills:
+        skill_name = skill_dir.name
+        tracked_hash = metadata.get("hash")
+        tracked_source = metadata.get("source")
+
+        # Validate metadata structure
+        if not tracked_hash or not tracked_source:
+            untracked += 1
+            results.append(
+                {
+                    "name": skill_name,
+                    "path": str(skill_dir),
+                    "status": "error",
+                    "message": "Corrupted metadata (missing hash or source)",
+                }
+            )
+            if not args.quiet and not args.json:
+                print(f"  ✗ {skill_name}: corrupted metadata", file=sys.stderr)
+            continue
+
+        # Check if in registry
+        from registry import load_registry
+
+        try:
+            entries = load_registry()
+        except Exception as e:
+            if not args.quiet and not args.json:
+                print(f"Error loading registry: {e}", file=sys.stderr)
+            return 1
+
+        entry = next((e for e in entries if e.name == skill_name), None)
+
+        if entry:
+            try:
+                manifest = load_manifest(skill_name)
+            except Exception as e:
+                untracked += 1
+                results.append(
+                    {"name": skill_name, "path": str(skill_dir), "status": "error", "message": f"Manifest error: {e}"}
+                )
+                if not args.quiet and not args.json:
+                    print(f"  ✗ {skill_name}: manifest error", file=sys.stderr)
+                continue
+
+            if manifest:
+                # Compare tracked hash with registry hash
+                if manifest.content_hash == tracked_hash:
+                    # Up to date
+                    status = "up-to-date"
+                    up_to_date += 1
+                    message = "Current"
+                else:
+                    # Registry has changed
+                    status = "outdated"
+                    outdated += 1
+                    message = "Registry has newer version"
+            else:
+                status = "untracked"
+                untracked += 1
+                message = "No manifest"
+        else:
+            status = "untracked"
+            untracked += 1
+            message = "Not in registry"
+
+        results.append(
+            {
+                "name": skill_name,
+                "path": str(skill_dir),
+                "status": status,
+                "message": message,
+                "tracked_hash": tracked_hash[:16] + "..." if tracked_hash else None,
+                "source": tracked_source,
+            }
+        )
+
+    if args.json:
+        print(
+            json.dumps(
+                {
+                    "tracked": len(tracked_skills),
+                    "up_to_date": up_to_date,
+                    "outdated": outdated,
+                    "modified": modified,
+                    "untracked": untracked,
+                    "skills": results,
+                },
+                indent=2,
+            )
+        )
+    else:
+        # Git-style output
+        for result in results:
+            if result["status"] == "up-to-date":
+                symbol = "✓"
+            elif result["status"] == "outdated":
+                symbol = "⚠"
+            elif result["status"] == "modified":
+                symbol = "✗"
+            else:
+                symbol = "?"
+
+            print(f"{symbol} {result['name']}: {result['status']}")
+            if not args.quiet:
+                print(f"  Path: {result['path']}")
+                if result["message"]:
+                    print(f"  {result['message']}")
+
+        print(
+            f"\n{len(tracked_skills)} tracked: {up_to_date} up-to-date, {outdated} outdated, {modified} modified, {untracked} untracked"
+        )
+
+        if outdated > 0:
+            print("\nRun 'oasr sync' to update outdated skills.")
+
+    return 1 if outdated > 0 or modified > 0 else 0

commands/exec.py

@@ -0,0 +1,245 @@
+"""Execute a skill from the registry using an agent CLI."""
+
+import argparse
+import sys
+from pathlib import Path
+
+import policy
+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.add_argument(
+        "--profile",
+        help="Execution policy profile to use (default: from config)",
+    )
+    parser.add_argument(
+        "-y",
+        "--yes",
+        action="store_true",
+        help="Skip confirmation prompt for risky operations",
+    )
+    parser.add_argument(
+        "--confirm",
+        action="store_true",
+        help="Force confirmation prompt even for safe operations",
+    )
+    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
+
+    # === POLICY ENFORCEMENT ===
+    # Load configuration
+    config = load_config()
+
+    # Determine which profile to use (flag overrides config)
+    profile_name = args.profile if args.profile else config.get("oasr", {}).get("default_profile", "safe")
+
+    # Load the policy profile
+    profile = policy.load(config, profile_name)
+
+    # Detect execution context for risk assessment
+    stdin_used = not sys.stdin.isatty() and not args.prompt and not args.instructions
+    instructions_file_used = bool(args.instructions)
+
+    # Assess risk and determine if confirmation is needed
+    needs_confirm, reasons = policy.assess_risk(
+        profile=profile,
+        stdin_used=stdin_used,
+        instructions_file_used=instructions_file_used,
+        force_confirm=args.confirm,
+    )
+
+    # Require confirmation unless --yes flag is present
+    if needs_confirm and not args.yes:
+        summary = policy.summarize(profile, skill_name, agent_name)
+        if not policy.prompt_confirmation(summary, reasons):
+            return 1  # User aborted
+
+    # === END POLICY ENFORCEMENT ===
+
+    # 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/find.py

@@ -0,0 +1,56 @@
+"""`asr find` command."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from discovery import find_skills
+from registry import SkillEntry, add_skill
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser("find", help="Find skills recursively")
+    p.add_argument("root", type=Path, help="Root directory to search")
+    p.add_argument("--add", action="store_true", dest="add_found", help="Register found skills")
+    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 run(args: argparse.Namespace) -> int:
+    root = args.root.resolve()
+
+    if not root.is_dir():
+        print(f"Error: Not a directory: {root}", file=sys.stderr)
+        return 2
+
+    skills = find_skills(root)
+
+    if args.json:
+        data = [{"name": s.name, "description": s.description, "path": str(s.path)} for s in skills]
+        print(json.dumps(data, indent=2))
+    else:
+        if not skills:
+            print(f"No skills found under {root}")
+        else:
+            for s in skills:
+                print(f"{s.name:<30}  {s.path}")
+
+    if args.add_found and skills:
+        added = 0
+        for s in skills:
+            entry = SkillEntry(
+                path=str(s.path),
+                name=s.name,
+                description=s.description,
+            )
+            if add_skill(entry):
+                added += 1
+
+        if not args.json and not args.quiet:
+            print(f"\nRegistered {added} new skill(s), {len(skills) - added} updated.")
+
+    return 0

commands/help.py

@@ -0,0 +1,51 @@
+"""`asr help` command."""
+
+from __future__ import annotations
+
+import argparse
+
+
+def register(subparsers, parser_ref: argparse.ArgumentParser) -> None:
+    """Register the help subcommand.
+
+    Args:
+        subparsers: The subparsers object to add to.
+        parser_ref: Reference to the main parser for displaying help.
+    """
+    p = subparsers.add_parser(
+        "help",
+        help="Show help for a command",
+        add_help=False,
+    )
+    p.add_argument(
+        "command",
+        nargs="?",
+        help="Command to show help for",
+    )
+    p.set_defaults(func=lambda args: run(args, parser_ref))
+
+
+def run(args: argparse.Namespace, parser: argparse.ArgumentParser) -> int:
+    """Show help for the specified command or general help."""
+    if not args.command:
+        parser.print_help()
+        return 0
+
+    # Find the subparser for the given command
+    subparsers_action = None
+    for action in parser._actions:
+        if isinstance(action, argparse._SubParsersAction):
+            subparsers_action = action
+            break
+
+    if subparsers_action is None:
+        print("Error: No commands available")
+        return 1
+
+    if args.command in subparsers_action.choices:
+        subparsers_action.choices[args.command].print_help()
+        return 0
+    else:
+        print(f"Unknown command: {args.command}")
+        print(f"\nAvailable commands: {', '.join(sorted(subparsers_action.choices.keys()))}")
+        return 1