oasr 0.3.4__py3-none-any.whl

commands/registry.py

@@ -0,0 +1,303 @@
+"""`oasr registry` command."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from manifest import (
+    check_manifest,
+    create_manifest,
+    load_manifest,
+    save_manifest,
+    sync_manifest,
+)
+from registry import load_registry, remove_skill
+from skillcopy.remote import is_remote_source
+
+
+def register(subparsers) -> None:
+    """Register the registry command and subcommands."""
+    p = subparsers.add_parser("registry", help="Manage skill registry (validate, add, remove, sync)")
+
+    # Subcommands
+    registry_subparsers = p.add_subparsers(dest="registry_command", help="Registry operation")
+
+    # registry (default - validate)
+    p.add_argument("-v", "--verbose", action="store_true", help="Show detailed per-skill status")
+    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")
+    p.set_defaults(func=run_validate)
+
+    # registry list
+    list_p = registry_subparsers.add_parser("list", help="List all registered skills")
+    list_p.add_argument("--json", action="store_true", help="Output in JSON format")
+    list_p.set_defaults(func=run_list)
+
+    # registry add
+    add_p = registry_subparsers.add_parser("add", help="Add skill(s) to registry")
+    add_p.add_argument("paths", nargs="+", help="Path(s) or URL(s) to skill directories")
+    add_p.add_argument("-r", "--recursive", action="store_true", help="Recursively discover skills")
+    add_p.add_argument("--strict", action="store_true", help="Fail on validation warnings")
+    add_p.add_argument("--json", action="store_true", help="Output in JSON format")
+    add_p.add_argument("--quiet", action="store_true", help="Suppress info/warnings")
+    add_p.add_argument("--config", type=Path, help="Override config file path")
+    add_p.set_defaults(func=run_add)
+
+    # registry rm
+    rm_p = registry_subparsers.add_parser("rm", help="Remove skill(s) from registry")
+    rm_p.add_argument("targets", nargs="+", help="Skill name(s), path(s), or glob pattern(s) to remove")
+    rm_p.add_argument("-r", "--recursive", action="store_true", help="Recursively remove skills")
+    rm_p.add_argument("--json", action="store_true", help="Output in JSON format")
+    rm_p.add_argument("--quiet", action="store_true", help="Suppress info/warnings")
+    rm_p.set_defaults(func=run_rm)
+
+    # registry sync
+    sync_p = registry_subparsers.add_parser("sync", help="Sync registry with remote sources")
+    sync_p.add_argument("names", nargs="*", help="Skill name(s) to sync (default: all)")
+    sync_p.add_argument("--prune", action="store_true", help="Remove skills with missing sources")
+    sync_p.add_argument("--json", action="store_true", help="Output in JSON format")
+    sync_p.add_argument("--quiet", action="store_true", help="Suppress info/warnings")
+    sync_p.add_argument("--config", type=Path, help="Override config file path")
+    sync_p.set_defaults(func=run_sync)
+
+
+def run_validate(args: argparse.Namespace) -> int:
+    """Validate registry manifests (default oasr registry behavior)."""
+    entries = load_registry()
+
+    if not entries:
+        if args.json:
+            print(json.dumps({"valid": 0, "modified": 0, "missing": 0}))
+        else:
+            print("No skills registered.")
+        return 0
+
+    # Check for remote skills
+    remote_count = sum(
+        1 for entry in entries if (manifest := load_manifest(entry.name)) and is_remote_source(manifest.source_path)
+    )
+
+    if remote_count > 0 and not args.quiet and not args.json:
+        print(f"Checking {remote_count} remote skill(s)...", file=sys.stderr)
+
+    valid_count = 0
+    modified_count = 0
+    missing_count = 0
+    results = []
+
+    for entry in entries:
+        manifest = load_manifest(entry.name)
+
+        if manifest is None:
+            # Create missing manifest
+            manifest = create_manifest(
+                name=entry.name,
+                source_path=Path(entry.path),
+                description=entry.description,
+            )
+            save_manifest(manifest)
+            valid_count += 1
+            status_info = {"name": entry.name, "status": "valid", "message": "Manifest created"}
+        else:
+            # Show progress for remote skills
+            is_remote = is_remote_source(manifest.source_path)
+            if is_remote and not args.quiet and not args.json:
+                platform = (
+                    "GitHub"
+                    if "github.com" in manifest.source_path
+                    else "GitLab"
+                    if "gitlab.com" in manifest.source_path
+                    else "remote"
+                )
+                print(f"  ↓ {entry.name} (checking {platform}...)", file=sys.stderr, flush=True)
+
+            status = check_manifest(manifest)
+
+            if is_remote and not args.quiet and not args.json:
+                print(f"  ✓ {entry.name} (checked)", file=sys.stderr)
+
+            if status.status == "valid":
+                valid_count += 1
+            elif status.status == "modified":
+                modified_count += 1
+            elif status.status == "missing":
+                missing_count += 1
+
+            status_info = status.to_dict()
+
+        results.append(status_info)
+
+    if args.json:
+        print(
+            json.dumps(
+                {
+                    "valid": valid_count,
+                    "modified": modified_count,
+                    "missing": missing_count,
+                    "results": results if args.verbose else None,
+                },
+                indent=2,
+            )
+        )
+    elif args.verbose:
+        # Detailed output (like old oasr status)
+        for result in results:
+            status_symbol = "✓" if result["status"] == "valid" else "⚠" if result["status"] == "modified" else "✗"
+            print(f"{status_symbol} {result['name']}: {result['status']}")
+            if result.get("message"):
+                print(f"  {result['message']}")
+    else:
+        # Summary output (like old oasr sync)
+        for result in results:
+            if result["status"] == "valid":
+                print(f"✓ {result['name']}: up to date")
+            elif result["status"] == "modified":
+                print(f"⚠ {result['name']}: modified")
+            elif result["status"] == "missing":
+                print(f"✗ {result['name']}: missing")
+
+        print(f"\n{valid_count} valid, {modified_count} modified, {missing_count} missing")
+
+    return 1 if missing_count > 0 else 0
+
+
+def run_list(args: argparse.Namespace) -> int:
+    """List all registered skills (oasr registry list)."""
+    from commands.list import run as list_run
+
+    return list_run(args)
+
+
+def run_add(args: argparse.Namespace) -> int:
+    """Add skills to registry (oasr registry add)."""
+    from commands.add import run as add_run
+
+    return add_run(args)
+
+
+def run_rm(args: argparse.Namespace) -> int:
+    """Remove skills from registry (oasr registry rm)."""
+    from commands.rm import run as rm_run
+
+    return rm_run(args)
+
+
+def run_sync(args: argparse.Namespace) -> int:
+    """Sync registry with remotes (oasr registry sync)."""
+    entries = load_registry()
+
+    if not entries:
+        if args.json:
+            print(json.dumps({"synced": 0, "error": "no skills registered"}))
+        else:
+            print("No skills registered.")
+        return 0
+
+    # Filter by names if provided
+    if args.names:
+        entry_map = {e.name: e for e in entries}
+        entries = [entry_map[n] for n in args.names if n in entry_map]
+        missing = [n for n in args.names if n not in entry_map]
+        if missing and not args.quiet:
+            for n in missing:
+                print(f"⚠ Skill not found: {n}", file=sys.stderr)
+
+    # Check for remote skills
+    remote_count = sum(
+        1 for entry in entries if (manifest := load_manifest(entry.name)) and is_remote_source(manifest.source_path)
+    )
+
+    if remote_count > 0 and not args.quiet and not args.json:
+        print(f"Checking {remote_count} remote skill(s)...", file=sys.stderr)
+
+    synced = 0
+    missing_count = 0
+    modified_count = 0
+    pruned = []
+    results = []
+
+    for entry in entries:
+        manifest = load_manifest(entry.name)
+
+        if manifest is None:
+            manifest = create_manifest(
+                name=entry.name,
+                source_path=Path(entry.path),
+                description=entry.description,
+            )
+            save_manifest(manifest)
+            status_info = {"name": entry.name, "status": "created", "message": "Manifest created"}
+        else:
+            # Show progress for remote skills
+            is_remote = is_remote_source(manifest.source_path)
+            if is_remote and not args.quiet and not args.json:
+                platform = (
+                    "GitHub"
+                    if "github.com" in manifest.source_path
+                    else "GitLab"
+                    if "gitlab.com" in manifest.source_path
+                    else "remote"
+                )
+                print(f"  ↓ {entry.name} (checking {platform}...)", file=sys.stderr, flush=True)
+
+            status = check_manifest(manifest)
+
+            if is_remote and not args.quiet and not args.json:
+                print(f"  ✓ {entry.name} (checked)", file=sys.stderr)
+
+            if status.status == "missing":
+                missing_count += 1
+                status_info = status.to_dict()
+
+                if args.prune:
+                    remove_skill(entry.name)
+                    pruned.append(entry.name)
+                    status_info["pruned"] = True
+            elif status.status == "modified":
+                modified_count += 1
+                # Update manifest
+                new_manifest = sync_manifest(manifest)
+                save_manifest(new_manifest)
+                synced += 1
+                status_info = {"name": entry.name, "status": "synced", "message": "Manifest updated"}
+            else:
+                status_info = status.to_dict()
+
+        results.append(status_info)
+
+    if args.json:
+        print(
+            json.dumps(
+                {
+                    "synced": synced,
+                    "missing": missing_count,
+                    "modified": modified_count,
+                    "pruned": len(pruned),
+                    "results": results,
+                },
+                indent=2,
+            )
+        )
+    else:
+        for result in results:
+            if result["status"] == "synced":
+                print(f"✓ {result['name']}: synced")
+            elif result["status"] == "modified":
+                print(f"⚠ {result['name']}: modified (use --update)")
+            elif result["status"] == "missing":
+                msg = f"✗ {result['name']}: missing"
+                if result.get("pruned"):
+                    msg += " (removed)"
+                print(msg)
+            else:
+                print(f"✓ {result['name']}: up to date")
+
+        print(f"\n{synced} synced, {modified_count} modified, {missing_count} missing")
+        if pruned:
+            print(f"{len(pruned)} skill(s) pruned")
+
+    return 1 if missing_count > 0 else 0

commands/rm.py

@@ -0,0 +1,128 @@
+"""`asr rm` command."""
+
+from __future__ import annotations
+
+import argparse
+import glob as globlib
+import json
+import sys
+from fnmatch import fnmatchcase
+from pathlib import Path
+
+from registry import load_registry, remove_skill
+
+_GLOB_CHARS = set("*?[")
+
+
+def _looks_like_glob(value: str) -> bool:
+    return any(ch in value for ch in _GLOB_CHARS)
+
+
+def _expand_path_patterns(patterns: list[str]) -> list[Path]:
+    expanded: list[Path] = []
+    for raw in patterns:
+        pat = str(Path(raw).expanduser())
+        if _looks_like_glob(pat):
+            matches = globlib.glob(pat, recursive=True)
+            expanded.extend(Path(m) for m in matches)
+        else:
+            expanded.append(Path(pat))
+    return expanded
+
+
+def _match_registry_targets(target: str, entries) -> list:
+    """Match a rm target against registry entries.
+
+    Rules:
+    - If target looks like a glob, match by name first (fnmatch), then by path.
+    - Otherwise match by exact name or exact path.
+    """
+    target_expanded = str(Path(target).expanduser())
+    if _looks_like_glob(target_expanded):
+        by_name = [e for e in entries if fnmatchcase(e.name, target_expanded)]
+        if by_name:
+            return by_name
+        return [e for e in entries if fnmatchcase(e.path, target_expanded)]
+
+    return [e for e in entries if e.name == target or e.path == target_expanded]
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser("rm", help="Unregister a skill")
+    p.add_argument("targets", nargs="+", help="Skill name(s), path(s), or glob pattern(s) to remove")
+    p.add_argument("-r", "--recursive", action="store_true", help="Recursively remove all skills under path")
+    p.add_argument("--json", action="store_true", help="Output in JSON format")
+    p.set_defaults(func=run)
+
+
+def run(args: argparse.Namespace) -> int:
+    if args.recursive:
+        return _run_recursive(args)
+
+    entries = load_registry()
+    removed_names: list[str] = []
+    missing: list[str] = []
+
+    for target in args.targets:
+        matches = _match_registry_targets(target, entries)
+        if not matches:
+            missing.append(target)
+            continue
+
+        for entry in matches:
+            if remove_skill(entry.name):
+                removed_names.append(entry.name)
+
+    # Deduplicate while preserving order.
+    seen = set()
+    removed_names = [n for n in removed_names if not (n in seen or seen.add(n))]
+
+    if args.json:
+        print(json.dumps({"removed": len(removed_names), "skills": removed_names, "missing": missing}, indent=2))
+    else:
+        for name in removed_names:
+            print(f"Removed: {name}")
+        for m in missing:
+            print(f"Not found: {m}", file=sys.stderr)
+
+        if removed_names and not missing:
+            print(f"\n{len(removed_names)} skill(s) removed")
+        elif removed_names and missing:
+            print(f"\n{len(removed_names)} skill(s) removed, {len(missing)} not found")
+
+    return 0 if removed_names and not missing else 1 if missing else 0
+
+
+def _run_recursive(args: argparse.Namespace) -> int:
+    roots = [p.resolve() for p in _expand_path_patterns(args.targets)]
+    for root in roots:
+        if not root.is_dir():
+            print(f"Error: Not a directory: {root}", file=sys.stderr)
+            return 2
+
+    entries = load_registry()
+    removed_names: list[str] = []
+
+    for root in roots:
+        root_str = str(root)
+        to_remove = [e for e in entries if e.path.startswith(root_str)]
+        for entry in to_remove:
+            if remove_skill(entry.name):
+                removed_names.append(entry.name)
+
+    # Deduplicate while preserving order.
+    seen = set()
+    removed_names = [n for n in removed_names if not (n in seen or seen.add(n))]
+
+    if args.json:
+        print(json.dumps({"removed": len(removed_names), "skills": removed_names}, indent=2))
+    else:
+        if not removed_names:
+            for root in roots:
+                print(f"No registered skills found under {root}")
+            return 0
+        for name in removed_names:
+            print(f"Removed: {name}")
+        print(f"\n{len(removed_names)} skill(s) removed")
+
+    return 0

commands/status.py

@@ -0,0 +1,119 @@
+"""`asr status` command."""
+
+from __future__ import annotations
+
+import argparse
+import json
+
+from manifest import check_manifest, load_manifest
+from registry import load_registry
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser("status", help="Show skill manifest status")
+    p.add_argument("names", nargs="*", help="Skill name(s) to check (default: all)")
+    p.add_argument("--json", action="store_true", help="Output in JSON format")
+    p.set_defaults(func=run)
+
+
+def run(args: argparse.Namespace) -> int:
+    entries = load_registry()
+
+    if not entries:
+        if args.json:
+            print("[]")
+        else:
+            print("No skills registered.")
+        return 0
+
+    if args.names:
+        entry_map = {e.name: e for e in entries}
+        entries = [entry_map[n] for n in args.names if n in entry_map]
+
+    # Check for remote skills and show progress header
+    from skillcopy.remote import is_remote_source
+
+    remote_count = 0
+    for entry in entries:
+        manifest = load_manifest(entry.name)
+        if manifest and is_remote_source(manifest.source_path):
+            remote_count += 1
+
+    if remote_count > 0 and not args.json:
+        import sys
+
+        print(f"Checking {remote_count} remote skill(s)...", file=sys.stderr)
+
+    results = []
+
+    for entry in entries:
+        manifest = load_manifest(entry.name)
+
+        if manifest is None:
+            status_info = {
+                "name": entry.name,
+                "status": "untracked",
+                "source_path": entry.path,
+                "message": "No manifest (run 'asr sync' to create)",
+            }
+        else:
+            # Show progress for remote skills
+            is_remote = is_remote_source(manifest.source_path)
+            if is_remote and not args.json:
+                import sys
+
+                platform = (
+                    "GitHub"
+                    if "github.com" in manifest.source_path
+                    else "GitLab"
+                    if "gitlab.com" in manifest.source_path
+                    else "remote"
+                )
+                print(f"  ↓ {entry.name} (checking {platform}...)", file=sys.stderr, flush=True)
+
+            status = check_manifest(manifest)
+            status_info = status.to_dict()
+
+            if is_remote and not args.json:
+                import sys
+
+                print(f"  ✓ {entry.name} (checked)", file=sys.stderr)
+
+        results.append(status_info)
+
+    if args.json:
+        print(json.dumps(results, indent=2))
+    else:
+        for r in results:
+            status = r.get("status", "unknown")
+            name = r.get("name", "?")
+
+            if status == "valid":
+                print(f"✓ {name}")
+            elif status == "untracked":
+                print(f"? {name} (untracked)")
+            elif status == "missing":
+                print(f"✗ {name} (source missing)")
+            elif status == "modified":
+                print(f"⚠ {name} (modified)")
+                if r.get("changed_files"):
+                    for f in r["changed_files"][:5]:
+                        print(f"    ~ {f}")
+                    if len(r["changed_files"]) > 5:
+                        print(f"    ... and {len(r['changed_files']) - 5} more")
+                if r.get("added_files"):
+                    for f in r["added_files"][:3]:
+                        print(f"    + {f}")
+                if r.get("removed_files"):
+                    for f in r["removed_files"][:3]:
+                        print(f"    - {f}")
+
+    valid = sum(1 for r in results if r.get("status") == "valid")
+    modified = sum(1 for r in results if r.get("status") == "modified")
+    missing = sum(1 for r in results if r.get("status") == "missing")
+    untracked = sum(1 for r in results if r.get("status") == "untracked")
+
+    if not args.json:
+        print(f"\n{valid} valid, {modified} modified, {missing} missing, {untracked} untracked")
+
+    return 0

commands/sync.py

@@ -0,0 +1,143 @@
+"""`oasr sync` command - refresh tracked local skills."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from manifest import load_manifest
+from skillcopy import copy_skill
+from tracking import extract_metadata
+
+
+def register(subparsers) -> None:
+    """Register the sync command."""
+    p = subparsers.add_parser("sync", help="Refresh outdated tracked skills from registry")
+    p.add_argument(
+        "path",
+        nargs="?",
+        type=Path,
+        default=Path.cwd(),
+        help="Path to scan for tracked skills (default: current directory)",
+    )
+    p.add_argument("--force", action="store_true", help="Overwrite modified skills (default: skip)")
+    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:
+    """Refresh outdated tracked skills."""
+    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({"updated": 0, "skipped": 0, "failed": 0}))
+        else:
+            print("No tracked skills found.")
+        return 0
+
+    # Check status and update outdated skills
+    from registry import load_registry
+
+    entries = load_registry()
+    entry_map = {e.name: e for e in entries}
+
+    updated = 0
+    skipped = 0
+    failed = 0
+    results = []
+
+    if not args.quiet and not args.json:
+        print(f"Found {len(tracked_skills)} tracked skill(s)...", file=sys.stderr)
+
+    for skill_dir, metadata in tracked_skills:
+        skill_name = skill_dir.name
+        tracked_hash = metadata.get("hash")
+
+        # Check if in registry
+        if skill_name not in entry_map:
+            skipped += 1
+            results.append(
+                {"name": skill_name, "path": str(skill_dir), "status": "skipped", "message": "Not in registry"}
+            )
+            if not args.quiet and not args.json:
+                print(f"  ? {skill_name}: skipped (not in registry)", file=sys.stderr)
+            continue
+
+        entry = entry_map[skill_name]
+        manifest = load_manifest(skill_name)
+
+        if not manifest:
+            skipped += 1
+            results.append({"name": skill_name, "path": str(skill_dir), "status": "skipped", "message": "No manifest"})
+            if not args.quiet and not args.json:
+                print(f"  ? {skill_name}: skipped (no manifest)", file=sys.stderr)
+            continue
+
+        # Check if outdated (compare tracked hash with registry hash)
+        if manifest.content_hash == tracked_hash:
+            # Already up-to-date
+            results.append({"name": skill_name, "path": str(skill_dir), "status": "up-to-date", "message": "Current"})
+            if not args.quiet and not args.json:
+                print(f"  ✓ {skill_name}: up to date", file=sys.stderr)
+            continue
+
+        # Update skill
+        try:
+            if not args.quiet and not args.json:
+                print(f"  ↻ {skill_name}: updating...", file=sys.stderr, flush=True)
+
+            copy_skill(entry.path, skill_dir, validate=False, inject_tracking=True, source_hash=manifest.content_hash)
+
+            updated += 1
+            results.append(
+                {"name": skill_name, "path": str(skill_dir), "status": "updated", "message": "Refreshed from registry"}
+            )
+            if not args.quiet and not args.json:
+                print(f"  ✓ {skill_name}: updated", file=sys.stderr)
+        except Exception as e:
+            failed += 1
+            results.append({"name": skill_name, "path": str(skill_dir), "status": "failed", "message": str(e)})
+            if not args.quiet and not args.json:
+                print(f"  ✗ {skill_name}: failed ({e})", file=sys.stderr)
+
+    if args.json:
+        print(
+            json.dumps(
+                {
+                    "updated": updated,
+                    "skipped": skipped,
+                    "failed": failed,
+                    "skills": results,
+                },
+                indent=2,
+            )
+        )
+    else:
+        if updated > 0 or skipped > 0 or failed > 0:
+            print(f"\n{updated} updated, {skipped} skipped, {failed} failed")
+        else:
+            print("All tracked skills up to date.")
+
+    return 1 if failed > 0 else 0