oasr 0.5.0__py3-none-any.whl

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

commands/update.py

@@ -0,0 +1,417 @@
+"""`oasr update` command - Update ASR tool from GitHub."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+
+def find_asr_repo() -> Path | None:
+    """Find the ASR git repository path.
+
+    Returns:
+        Path to ASR repo, or None if not found.
+    """
+    # Try to find via current module location
+    try:
+        import cli
+
+        cli_file = Path(cli.__file__).resolve()
+
+        # Walk up to find .git directory
+        current = cli_file.parent
+        for _ in range(5):  # Max 5 levels up
+            if (current / ".git").exists():
+                return current
+            if current.parent == current:  # Reached root
+                break
+            current = current.parent
+    except Exception:
+        pass
+
+    return None
+
+
+def get_git_remote_url(repo_path: Path) -> str | None:
+    """Get the git remote URL.
+
+    Args:
+        repo_path: Path to git repository.
+
+    Returns:
+        Remote URL or None.
+    """
+    try:
+        result = subprocess.run(
+            ["git", "remote", "get-url", "origin"],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except Exception:
+        pass
+    return None
+
+
+def get_current_commit(repo_path: Path) -> str | None:
+    """Get current git commit hash.
+
+    Args:
+        repo_path: Path to git repository.
+
+    Returns:
+        Commit hash or None.
+    """
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "HEAD"],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except Exception:
+        pass
+    return None
+
+
+def check_working_tree_clean(repo_path: Path) -> bool:
+    """Check if git working tree is clean.
+
+    Args:
+        repo_path: Path to git repository.
+
+    Returns:
+        True if clean, False if dirty.
+    """
+    try:
+        result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        return result.returncode == 0 and not result.stdout.strip()
+    except Exception:
+        return False
+
+
+def pull_updates(repo_path: Path) -> tuple[bool, str]:
+    """Pull updates from git remote.
+
+    Args:
+        repo_path: Path to git repository.
+
+    Returns:
+        Tuple of (success, message).
+    """
+    try:
+        result = subprocess.run(
+            ["git", "pull", "--ff-only"],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        if result.returncode == 0:
+            # Check if already up to date
+            if "Already up to date" in result.stdout or "Already up-to-date" in result.stdout:
+                return True, "already_up_to_date"
+            return True, "updated"
+        else:
+            return False, result.stderr.strip()
+    except subprocess.TimeoutExpired:
+        return False, "Update timed out"
+    except Exception as e:
+        return False, str(e)
+
+
+def get_changelog(repo_path: Path, old_commit: str, new_commit: str, max_lines: int = 10) -> list[str]:
+    """Get changelog between two commits.
+
+    Args:
+        repo_path: Path to git repository.
+        old_commit: Old commit hash.
+        new_commit: New commit hash.
+        max_lines: Maximum number of commits to show.
+
+    Returns:
+        List of commit messages.
+    """
+    try:
+        result = subprocess.run(
+            ["git", "log", "--oneline", f"{old_commit}..{new_commit}", f"-{max_lines}"],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+
+        if result.returncode == 0 and result.stdout.strip():
+            return result.stdout.strip().split("\n")
+    except Exception:
+        pass
+    return []
+
+
+def get_stats(repo_path: Path, old_commit: str, new_commit: str) -> dict:
+    """Get statistics about changes.
+
+    Args:
+        repo_path: Path to git repository.
+        old_commit: Old commit hash.
+        new_commit: New commit hash.
+
+    Returns:
+        Dictionary with stats (commits, files, insertions, deletions).
+    """
+    stats = {"commits": 0, "files": 0, "insertions": 0, "deletions": 0}
+
+    try:
+        # Count commits
+        result = subprocess.run(
+            ["git", "rev-list", "--count", f"{old_commit}..{new_commit}"],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            stats["commits"] = int(result.stdout.strip())
+
+        # Get file stats
+        result = subprocess.run(
+            ["git", "diff", "--shortstat", old_commit, new_commit],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            # Parse: "5 files changed, 123 insertions(+), 45 deletions(-)"
+            output = result.stdout.strip()
+            if "file" in output:
+                parts = output.split(",")
+                for part in parts:
+                    if "file" in part:
+                        stats["files"] = int(part.split()[0])
+                    elif "insertion" in part:
+                        stats["insertions"] = int(part.split()[0])
+                    elif "deletion" in part:
+                        stats["deletions"] = int(part.split()[0])
+    except Exception:
+        pass
+
+    return stats
+
+
+def reinstall_asr(repo_path: Path) -> tuple[bool, str]:
+    """Reinstall ASR using uv or pip.
+
+    Args:
+        repo_path: Path to ASR repository.
+
+    Returns:
+        Tuple of (success, message).
+    """
+    # Try uv first
+    try:
+        result = subprocess.run(
+            ["uv", "pip", "install", "-e", "."],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+        if result.returncode == 0:
+            return True, "Reinstalled with uv"
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        pass
+
+    # Fall back to pip
+    try:
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "install", "-e", "."],
+            cwd=repo_path,
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+        if result.returncode == 0:
+            return True, "Reinstalled with pip"
+        else:
+            return False, result.stderr.strip()
+    except Exception as e:
+        return False, str(e)
+
+
+def register(subparsers) -> None:
+    """Register the update command."""
+    p = subparsers.add_parser(
+        "update",
+        help="Update ASR tool from GitHub",
+    )
+    p.add_argument(
+        "--no-reinstall",
+        action="store_true",
+        help="Skip reinstallation step",
+    )
+    p.add_argument(
+        "--changelog",
+        type=int,
+        default=10,
+        metavar="N",
+        help="Number of changelog entries to show (default: 10)",
+    )
+    p.add_argument(
+        "--json",
+        action="store_true",
+        help="Output in JSON format",
+    )
+    p.add_argument(
+        "--quiet",
+        action="store_true",
+        help="Suppress info messages",
+    )
+    p.set_defaults(func=run)
+
+
+def run(args: argparse.Namespace) -> int:
+    """Run the update command."""
+    # Find ASR repository
+    repo_path = find_asr_repo()
+
+    if not repo_path:
+        if args.json:
+            print(json.dumps({"success": False, "error": "Could not find ASR git repository"}))
+        else:
+            print("✗ Could not find ASR git repository", file=sys.stderr)
+            print("  Make sure ASR is installed from git (git clone + pip install -e .)", file=sys.stderr)
+        return 1
+
+    if not args.quiet and not args.json:
+        print(f"Found ASR repository: {repo_path}")
+
+    # Check if it's a git repository
+    if not (repo_path / ".git").exists():
+        if args.json:
+            print(json.dumps({"success": False, "error": "Not a git repository"}))
+        else:
+            print(f"✗ {repo_path} is not a git repository", file=sys.stderr)
+        return 1
+
+    # Get remote URL
+    remote_url = get_git_remote_url(repo_path)
+    if remote_url and not args.quiet and not args.json:
+        print(f"Remote: {remote_url}")
+
+    # Check working tree
+    if not check_working_tree_clean(repo_path):
+        if args.json:
+            print(json.dumps({"success": False, "error": "Working tree has uncommitted changes"}))
+        else:
+            print("✗ Working tree has uncommitted changes", file=sys.stderr)
+            print("  Commit or stash your changes before updating", file=sys.stderr)
+        return 1
+
+    # Get current commit before update
+    old_commit = get_current_commit(repo_path)
+    if not old_commit:
+        if args.json:
+            print(json.dumps({"success": False, "error": "Could not get current commit"}))
+        else:
+            print("✗ Could not get current commit", file=sys.stderr)
+        return 1
+
+    # Pull updates
+    if not args.quiet and not args.json:
+        print("Pulling updates from GitHub...")
+
+    success, message = pull_updates(repo_path)
+
+    if not success:
+        if args.json:
+            print(json.dumps({"success": False, "error": f"Git pull failed: {message}"}))
+        else:
+            print(f"✗ Git pull failed: {message}", file=sys.stderr)
+        return 1
+
+    # Check if already up to date
+    if message == "already_up_to_date":
+        if args.json:
+            print(json.dumps({"success": True, "updated": False, "message": "Already up to date"}))
+        else:
+            print("✓ Already up to date")
+        return 0
+
+    # Get new commit
+    new_commit = get_current_commit(repo_path)
+    if not new_commit or new_commit == old_commit:
+        if args.json:
+            print(json.dumps({"success": True, "updated": False, "message": "No changes"}))
+        else:
+            print("✓ No changes")
+        return 0
+
+    # Get statistics
+    stats = get_stats(repo_path, old_commit, new_commit)
+
+    # Get changelog
+    changelog = get_changelog(repo_path, old_commit, new_commit, max_lines=args.changelog)
+
+    if args.json:
+        print(
+            json.dumps(
+                {
+                    "success": True,
+                    "updated": True,
+                    "old_commit": old_commit[:7],
+                    "new_commit": new_commit[:7],
+                    "stats": stats,
+                    "changelog": changelog,
+                },
+                indent=2,
+            )
+        )
+    else:
+        print(f"✓ Updated ASR from {old_commit[:7]} to {new_commit[:7]}")
+        print(f"  {stats['commits']} commit(s), {stats['files']} file(s) changed", end="")
+        if stats["insertions"] > 0:
+            print(f", +{stats['insertions']}", end="")
+        if stats["deletions"] > 0:
+            print(f", -{stats['deletions']}", end="")
+        print()
+
+        if changelog:
+            print("\nRecent changes:")
+            for line in changelog:
+                print(f"  {line}")
+
+    # Reinstall if requested
+    if not args.no_reinstall:
+        if not args.quiet and not args.json:
+            print("\nReinstalling ASR...")
+
+        success, message = reinstall_asr(repo_path)
+
+        if success:
+            if not args.quiet and not args.json:
+                print(f"✓ {message}")
+        else:
+            if args.json:
+                print(json.dumps({"warning": f"Reinstall failed: {message}"}), file=sys.stderr)
+            else:
+                print(f"⚠ Reinstall failed: {message}", file=sys.stderr)
+                print("  You may need to reinstall manually", file=sys.stderr)
+
+    return 0

commands/use.py

@@ -0,0 +1,45 @@
+"""`asr use` command - DEPRECATED, use `oasr clone` instead."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from commands import clone
+
+
+def register(subparsers) -> None:
+    """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",
+        "--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 run(args: argparse.Namespace) -> int:
+    """Execute the deprecated use command (delegates to clone)."""
+    # Show deprecation warning unless --quiet or --json
+    if not args.quiet and not args.json:
+        print(
+            "⚠ Warning: 'oasr use' is deprecated. Use 'oasr clone' instead.",
+            file=sys.stderr,
+        )
+        print("  This command will be removed in v0.5.0.", file=sys.stderr)
+        print(file=sys.stderr)
+
+    # Delegate to clone command
+    return clone.run(args)

commands/validate.py

@@ -0,0 +1,74 @@
+"""`asr validate` command."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from config import load_config
+from registry import load_registry
+from validate import validate_all, validate_skill
+
+
+def _print_validation_result(result) -> None:
+    print(f"{result.name}")
+    if result.valid and not result.warnings:
+        print("  ✓ Valid")
+    else:
+        for msg in result.all_messages:
+            print(f"  {msg}")
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser("validate", help="Validate skills")
+    p.add_argument("path", type=Path, nargs="?", help="Path to skill directory")
+    p.add_argument("--all", action="store_true", dest="validate_all", help="Validate all registered skills")
+    p.add_argument("--strict", action="store_true", help="Treat warnings as errors")
+    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)
+
+
+def run(args: argparse.Namespace) -> int:
+    config = load_config(args.config)
+    max_lines = config["validation"]["reference_max_lines"]
+
+    if args.validate_all:
+        entries = load_registry()
+        if not entries:
+            if args.json:
+                print("[]")
+            else:
+                print("No skills registered.")
+            return 0
+
+        results = validate_all(entries, reference_max_lines=max_lines)
+    elif args.path:
+        result = validate_skill(args.path.resolve(), reference_max_lines=max_lines)
+        results = [result]
+    else:
+        print("Error: Specify a path or use --all", file=sys.stderr)
+        return 2
+
+    if args.json:
+        print(json.dumps([r.to_dict() for r in results], indent=2))
+    else:
+        for result in results:
+            _print_validation_result(result)
+            print()
+
+    total_errors = sum(len(r.errors) for r in results)
+    total_warnings = sum(len(r.warnings) for r in results)
+
+    if not args.json and not args.quiet:
+        print(f"{len(results)} skill(s) validated: {total_errors} error(s), {total_warnings} warning(s)")
+
+    if total_errors > 0:
+        return 1
+    if args.strict and total_warnings > 0:
+        return 1
+
+    return 0