oasr 0.3.4__py3-none-any.whl

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,172 @@
+"""`asr use` command."""
+
+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:
+    p = subparsers.add_parser("use", help="Copy skill(s) to target directory")
+    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 _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:
+    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 copy {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 copy {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"Copied: {c['name']} → {c['dest']}")
+        if copied:
+            print(f"\n{len(copied)} skill(s) copied to {output_dir}")
+
+    return 1 if warnings and not copied else 0

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