oasr 0.3.4__py3-none-any.whl

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/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

commands/info.py

@@ -0,0 +1,152 @@
+"""Info command - show detailed information about a skill."""
+
+import argparse
+import json
+import sys
+from datetime import datetime
+
+from manifest import check_manifest, load_manifest
+from registry import load_registry
+from skillcopy.remote import is_remote_source
+
+
+def run(args: argparse.Namespace) -> int:
+    """Show detailed information about a skill.
+
+    Args:
+        args: Parsed command-line arguments
+
+    Returns:
+        Exit code (0 for success, non-zero for errors)
+    """
+    skill_name = args.skill_name
+
+    # Load registry to verify skill exists
+    entries = load_registry()
+    entry = None
+    for e in entries:
+        if e.name == skill_name:
+            entry = e
+            break
+
+    if not entry:
+        if not args.quiet:
+            print(f"Error: Skill '{skill_name}' not found", file=sys.stderr)
+            print("Try: oasr list", file=sys.stderr)
+        return 1
+
+    # Load manifest
+    manifest = load_manifest(skill_name)
+    if not manifest:
+        if not args.quiet:
+            print(f"No manifest found for: {skill_name}", file=sys.stderr)
+        return 1
+
+    # Check if remote and show progress indicator
+    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"Checking remote skill status from {platform}...", file=sys.stderr, flush=True)
+
+    # Check status
+    status_result = check_manifest(manifest)
+
+    # Determine type
+    is_remote = is_remote_source(manifest.source_path)
+    if is_remote:
+        if "github.com" in manifest.source_path:
+            skill_type = "Remote (GitHub)"
+        elif "gitlab.com" in manifest.source_path:
+            skill_type = "Remote (GitLab)"
+        else:
+            skill_type = "Remote"
+    else:
+        skill_type = "Local"
+
+    # Format registered date
+    try:
+        reg_date = datetime.fromisoformat(manifest.registered_at.replace("Z", "+00:00"))
+        reg_date_str = reg_date.strftime("%Y-%m-%d %H:%M:%S UTC")
+    except Exception:
+        reg_date_str = manifest.registered_at
+
+    # Prepare data
+    info = {
+        "name": manifest.name,
+        "description": manifest.description,
+        "source": manifest.source_path,
+        "type": skill_type,
+        "status": status_result.status,
+        "file_count": len(manifest.files),
+        "content_hash": manifest.content_hash,
+        "registered_at": reg_date_str,
+    }
+
+    if args.files:
+        info["files"] = [{"path": f.path, "hash": f.hash} for f in manifest.files]
+
+    # Output
+    if args.json:
+        print(json.dumps(info, indent=2))
+    else:
+        # Human-readable format
+        status_icon = {
+            "valid": "✓",
+            "modified": "↻",
+            "missing": "✗",
+        }.get(status_result.status, "?")
+
+        print(f"\n[{manifest.name}]")
+        print("---")
+        print(manifest.description)
+        print("---")
+        print(f"Source: {manifest.source_path}")
+        print(f"Type: {skill_type}")
+        print(f"Status: {status_icon} {status_result.status.capitalize()}")
+        if status_result.message:
+            print(f"  {status_result.message}")
+        print(f"Files: {len(manifest.files)}")
+        print(f"Hash: {manifest.content_hash[:20]}...")
+        print(f"Registered: {reg_date_str}")
+
+        if args.files and manifest.files:
+            print(f"\nFiles ({len(manifest.files)}):")
+            for file_info in manifest.files:
+                print(f"  - {file_info.path}")
+
+        print()
+
+    return 0
+
+
+def register(subparsers):
+    """Register the info command with argparse.
+
+    Args:
+        subparsers: Subparsers object from argparse
+    """
+    parser = subparsers.add_parser(
+        "info",
+        help="Show detailed information about a skill",
+        description="Display detailed information about a registered skill including "
+        "metadata, status, and optionally the list of files.",
+    )
+
+    parser.add_argument(
+        "skill_name",
+        help="Skill name to show information for",
+    )
+
+    parser.add_argument(
+        "--files",
+        action="store_true",
+        help="Show list of files in the skill",
+    )
+
+    parser.set_defaults(func=run)

commands/list.py

@@ -0,0 +1,110 @@
+"""`asr list` command."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import textwrap
+from shutil import get_terminal_size
+
+from registry import load_registry
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser("list", help="List registered skills")
+    p.add_argument("--json", action="store_true", help="Output in JSON format")
+    p.add_argument("--verbose", "-v", action="store_true", help="Show full paths")
+    p.set_defaults(func=run)
+
+
+def _shorten_path(path: str, max_len: int = 40) -> str:
+    """Shorten a path for display, using ~ for home directory."""
+    home = os.path.expanduser("~")
+    if path.startswith(home):
+        path = "~" + path[len(home) :]
+
+    if len(path) <= max_len:
+        return path
+
+    # Truncate middle of path
+    parts = path.split(os.sep)
+    if len(parts) <= 2:
+        return path[: max_len - 3] + "..."
+
+    # Keep first and last parts, truncate middle
+    result = parts[0] + os.sep + "..." + os.sep + parts[-1]
+    if len(result) <= max_len:
+        # Try to add more parts from the end
+        for i in range(len(parts) - 2, 0, -1):
+            candidate = parts[0] + os.sep + "..." + os.sep.join(parts[i:])
+            if len(candidate) <= max_len:
+                result = candidate
+            else:
+                break
+    return result
+
+
+def _wrap_description(desc: str, width: int, indent: int = 3) -> str:
+    """Wrap description text with proper indentation."""
+    if not desc:
+        return ""
+    prefix = " " * indent
+    wrapped = textwrap.fill(
+        desc.strip(),
+        width=max(20, width - indent),
+        initial_indent=prefix,
+        subsequent_indent=prefix,
+    )
+    return wrapped
+
+
+def run(args: argparse.Namespace) -> int:
+    entries = load_registry()
+
+    if not entries:
+        if args.json:
+            print("[]")
+        else:
+            print("No skills registered. Use 'asr add <path>' to register a skill.")
+        return 0
+
+    if args.json:
+        data = [{"name": e.name, "description": e.description, "path": e.path} for e in entries]
+        print(json.dumps(data, indent=2))
+        return 0
+
+    width = min(100, max(60, get_terminal_size((80, 20)).columns))
+    verbose = getattr(args, "verbose", False)
+
+    # Header
+    print(f"\n  REGISTERED SKILLS ({len(entries)})\n")
+
+    # Calculate max name length for alignment
+    max_name = max(len(e.name) for e in entries)
+    path_width = width - max_name - 10  # Account for formatting
+
+    for e in sorted(entries, key=lambda x: x.name):
+        name = e.name
+
+        if verbose:
+            path_display = e.path
+        else:
+            path_display = _shorten_path(e.path, max(20, path_width))
+
+        # Skill header with box drawing
+        print(f"  ┌─ {name}")
+        print(f"  │  {path_display}")
+
+        desc = (e.description or "").strip()
+        if desc:
+            # Truncate description to one line if too long
+            max_desc = width - 6
+            if len(desc) > max_desc:
+                desc = desc[: max_desc - 3] + "..."
+            print(f"  └─ {desc}")
+        else:
+            print("  └─ (no description)")
+        print()
+
+    return 0