oasr 0.5.0__py3-none-any.whl

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