agr 0.4.0__py3-none-any.whl

agr/cli/init.py

@@ -0,0 +1,292 @@
+"""Init subcommand for agr - create new resources and repos."""
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from agr.github import check_gh_cli, create_github_repo, get_github_username, repo_exists
+from agr.scaffold import (
+    create_agent_resources_repo,
+    init_git,
+    scaffold_repo,
+    write_gitignore,
+    write_readme,
+    write_starter_agent,
+    write_starter_command,
+    write_starter_skill,
+)
+
+console = Console()
+
+app = typer.Typer(
+    help="Create new agent resources or repositories.",
+    no_args_is_help=True,
+)
+
+
+@app.command("repo")
+def init_repo(
+    name: Annotated[
+        str,
+        typer.Argument(
+            help="Name of the repository to create, or '.' for current directory",
+            metavar="NAME",
+        ),
+    ] = "agent-resources",
+    path: Annotated[
+        Path | None,
+        typer.Option(
+            "--path",
+            "-p",
+            help="Custom path for the repository (default: ./<name>)",
+        ),
+    ] = None,
+    github: Annotated[
+        bool,
+        typer.Option(
+            "--github",
+            "-g",
+            help="Create a GitHub repository and push",
+        ),
+    ] = False,
+) -> None:
+    """Create a new agent-resources repository with starter content.
+
+    Creates a directory structure with example skill, command, and agent files.
+
+    Examples:
+      agr init repo                          # Creates ./agent-resources/
+      agr init repo my-resources             # Creates ./my-resources/
+      agr init repo .                        # Initialize in current directory
+      agr init repo agent-resources --github # Creates and pushes to GitHub
+    """
+    # Determine target path
+    if name == ".":
+        target_path = Path.cwd()
+        # Use directory name for GitHub repo name
+        name = target_path.name
+    else:
+        target_path = path or Path.cwd() / name
+
+        if target_path.exists():
+            console.print(f"[red]Error: Directory already exists: {target_path}[/red]")
+            raise typer.Exit(1)
+
+    # Check if .claude directory already exists
+    claude_dir = target_path / ".claude"
+    if claude_dir.exists():
+        console.print(f"[red]Error: .claude directory already exists at {claude_dir}[/red]")
+        raise typer.Exit(1)
+
+    # Check GitHub CLI if --github flag is set
+    if github:
+        if not check_gh_cli():
+            console.print(
+                "[red]Error: GitHub CLI (gh) is not installed or not authenticated.[/red]\n"
+                "Install it from https://cli.github.com/ and run 'gh auth login'"
+            )
+            raise typer.Exit(1)
+
+        if repo_exists(name):
+            console.print(f"[red]Error: GitHub repository '{name}' already exists.[/red]")
+            raise typer.Exit(1)
+
+    # Get GitHub username for README
+    username = get_github_username() or "<username>"
+
+    # Create the repository
+    console.print(f"Creating agent-resources repository at {target_path}...")
+    create_agent_resources_repo(target_path, username)
+
+    # Initialize git
+    if init_git(target_path):
+        console.print("[green]Initialized git repository[/green]")
+    else:
+        console.print("[yellow]Warning: Could not initialize git repository[/yellow]")
+
+    # Create GitHub repo if requested
+    if github:
+        console.print("Creating GitHub repository...")
+        repo_url = create_github_repo(target_path, name)
+        if repo_url:
+            console.print(f"[green]Created and pushed to {repo_url}[/green]")
+            console.print(f"\nOthers can now install your resources:")
+            console.print(f"  agr add skill {username}/hello-world")
+            console.print(f"  agr add command {username}/hello")
+            console.print(f"  agr add agent {username}/hello-agent")
+        else:
+            console.print("[yellow]Warning: Could not create GitHub repository[/yellow]")
+    else:
+        console.print(f"\n[green]Created agent-resources repository at {target_path}[/green]")
+        console.print("\nNext steps:")
+        console.print(f"  cd {target_path}")
+        console.print("  git remote add origin <your-repo-url>")
+        console.print("  git push -u origin main")
+
+
+@app.command("skill")
+def init_skill(
+    name: Annotated[
+        str,
+        typer.Argument(
+            help="Name of the skill to create",
+            metavar="NAME",
+        ),
+    ],
+    path: Annotated[
+        Path | None,
+        typer.Option(
+            "--path",
+            "-p",
+            help="Custom path (default: ./.claude/skills/<name>/)",
+        ),
+    ] = None,
+) -> None:
+    """Create a new skill scaffold.
+
+    Examples:
+      agr init skill my-skill
+      agr init skill code-reviewer --path ./custom/path/
+    """
+    target_path = path or (Path.cwd() / ".claude" / "skills" / name)
+    skill_file = target_path / "SKILL.md"
+
+    if skill_file.exists():
+        console.print(f"[red]Error: Skill already exists at {skill_file}[/red]")
+        raise typer.Exit(1)
+
+    target_path.mkdir(parents=True, exist_ok=True)
+
+    skill_content = f"""\
+---
+name: {name}
+description: Description of what this skill does
+---
+
+# {name.replace('-', ' ').title()} Skill
+
+Describe what this skill does and when Claude should apply it.
+
+## When to Use
+
+Describe the situations when this skill should be applied.
+
+## Instructions
+
+Provide specific instructions for Claude to follow.
+"""
+    skill_file.write_text(skill_content)
+    console.print(f"[green]Created skill at {skill_file}[/green]")
+
+
+@app.command("command")
+def init_command(
+    name: Annotated[
+        str,
+        typer.Argument(
+            help="Name of the command to create (without leading slash)",
+            metavar="NAME",
+        ),
+    ],
+    path: Annotated[
+        Path | None,
+        typer.Option(
+            "--path",
+            "-p",
+            help="Custom path (default: ./.claude/commands/<name>.md)",
+        ),
+    ] = None,
+) -> None:
+    """Create a new slash command scaffold.
+
+    Examples:
+      agr init command my-command
+      agr init command deploy --path ./custom/path/
+    """
+    target_path = path or (Path.cwd() / ".claude" / "commands")
+    command_file = target_path / f"{name}.md"
+
+    if command_file.exists():
+        console.print(f"[red]Error: Command already exists at {command_file}[/red]")
+        raise typer.Exit(1)
+
+    target_path.mkdir(parents=True, exist_ok=True)
+
+    command_content = f"""\
+---
+description: Description of /{name} command
+---
+
+When the user runs /{name}, do the following:
+
+1. First step
+2. Second step
+3. Third step
+
+Provide clear, actionable instructions for what Claude should do.
+"""
+    command_file.write_text(command_content)
+    console.print(f"[green]Created command at {command_file}[/green]")
+
+
+@app.command("agent")
+def init_agent(
+    name: Annotated[
+        str,
+        typer.Argument(
+            help="Name of the agent to create",
+            metavar="NAME",
+        ),
+    ],
+    path: Annotated[
+        Path | None,
+        typer.Option(
+            "--path",
+            "-p",
+            help="Custom path (default: ./.claude/agents/<name>.md)",
+        ),
+    ] = None,
+) -> None:
+    """Create a new sub-agent scaffold.
+
+    Examples:
+      agr init agent my-agent
+      agr init agent test-writer --path ./custom/path/
+    """
+    target_path = path or (Path.cwd() / ".claude" / "agents")
+    agent_file = target_path / f"{name}.md"
+
+    if agent_file.exists():
+        console.print(f"[red]Error: Agent already exists at {agent_file}[/red]")
+        raise typer.Exit(1)
+
+    target_path.mkdir(parents=True, exist_ok=True)
+
+    agent_content = f"""\
+---
+description: Description of the {name} sub-agent
+---
+
+You are a specialized sub-agent for {name.replace('-', ' ')}.
+
+## Purpose
+
+Describe the specific purpose and capabilities of this agent.
+
+## Instructions
+
+When invoked, you should:
+
+1. First action
+2. Second action
+3. Third action
+
+## Constraints
+
+- Constraint 1
+- Constraint 2
+"""
+    agent_file.write_text(agent_content)
+    console.print(f"[green]Created agent at {agent_file}[/green]")

agr/cli/main.py

@@ -0,0 +1,34 @@
+"""Main CLI entrypoint for agr."""
+
+import typer
+
+from agr.cli.add import app as add_app
+from agr.cli.init import app as init_app
+from agr.cli.remove import app as remove_app
+from agr.cli.sync import sync as sync_command
+from agr.cli.update import app as update_app
+
+app = typer.Typer(
+    name="agr",
+    help="Agent Resources - Install and create Claude Code skills, commands, and agents.",
+    add_completion=False,
+    no_args_is_help=True,
+)
+
+# Register subcommands
+app.add_typer(add_app, name="add")
+app.add_typer(init_app, name="init")
+app.add_typer(remove_app, name="remove")
+app.add_typer(update_app, name="update")
+
+# Register sync command
+app.command()(sync_command)
+
+
+def main() -> None:
+    """Main entry point."""
+    app()
+
+
+if __name__ == "__main__":
+    main()

agr/cli/remove.py

@@ -0,0 +1,125 @@
+"""Remove subcommand for agr - delete local resources."""
+
+from typing import Annotated, List, Optional
+
+import typer
+from rich.console import Console
+
+from agr.cli.common import handle_remove_bundle, handle_remove_resource, handle_remove_unified
+from agr.fetcher import ResourceType
+
+console = Console()
+
+# Deprecated subcommand names
+DEPRECATED_SUBCOMMANDS = {"skill", "command", "agent", "bundle"}
+
+
+def extract_type_from_args(
+    args: list[str] | None, explicit_type: str | None
+) -> tuple[list[str], str | None]:
+    """
+    Extract --type/-t option from args list if present.
+
+    When --type or -t appears after the resource name, Typer captures it
+    as part of the variadic args list. This function extracts it.
+
+    Args:
+        args: The argument list (may contain --type/-t)
+        explicit_type: The resource_type value from Typer (may be None if type was in args)
+
+    Returns:
+        Tuple of (cleaned_args, resource_type)
+    """
+    if not args or explicit_type is not None:
+        return args or [], explicit_type
+
+    cleaned_args = []
+    resource_type = None
+    i = 0
+    while i < len(args):
+        if args[i] in ("--type", "-t") and i + 1 < len(args):
+            resource_type = args[i + 1]
+            i += 2  # Skip both --type and its value
+        else:
+            cleaned_args.append(args[i])
+            i += 1
+
+    return cleaned_args, resource_type
+
+app = typer.Typer(
+    help="Remove skills, commands, or agents.",
+)
+
+
+@app.callback(invoke_without_command=True)
+def remove_unified(
+    ctx: typer.Context,
+    args: Annotated[
+        Optional[List[str]],
+        typer.Argument(help="Name of the resource to remove"),
+    ] = None,
+    resource_type: Annotated[
+        Optional[str],
+        typer.Option(
+            "--type",
+            "-t",
+            help="Explicit resource type: skill, command, agent, or bundle",
+        ),
+    ] = None,
+    global_install: Annotated[
+        bool,
+        typer.Option(
+            "--global",
+            "-g",
+            help="Remove from ~/.claude/ instead of ./.claude/",
+        ),
+    ] = False,
+) -> None:
+    """Remove a resource from the local installation with auto-detection.
+
+    Auto-detects the resource type (skill, command, agent) from local files.
+    Use --type to explicitly specify when a name exists in multiple types.
+
+    Examples:
+      agr remove hello-world
+      agr remove hello-world --type skill
+      agr remove hello-world --global
+    """
+    # Extract --type/-t from args if it was captured there (happens when type comes after name)
+    cleaned_args, resource_type = extract_type_from_args(args, resource_type)
+
+    if not cleaned_args:
+        console.print(ctx.get_help())
+        raise typer.Exit(0)
+
+    first_arg = cleaned_args[0]
+
+    # Handle deprecated subcommand syntax: agr remove skill <name>
+    if first_arg in DEPRECATED_SUBCOMMANDS:
+        if len(cleaned_args) < 2:
+            console.print(f"[red]Error: Missing resource name after '{first_arg}'.[/red]")
+            raise typer.Exit(1)
+
+        name = cleaned_args[1]
+        if first_arg == "bundle":
+            console.print(
+                f"[yellow]Warning: 'agr remove bundle' is deprecated. "
+                f"Use 'agr remove {name} --type bundle' instead.[/yellow]"
+            )
+            handle_remove_bundle(name, global_install)
+        else:
+            console.print(
+                f"[yellow]Warning: 'agr remove {first_arg}' is deprecated. "
+                f"Use 'agr remove {name}' instead.[/yellow]"
+            )
+            if first_arg == "skill":
+                handle_remove_resource(name, ResourceType.SKILL, "skills", global_install)
+            elif first_arg == "command":
+                handle_remove_resource(name, ResourceType.COMMAND, "commands", global_install)
+            elif first_arg == "agent":
+                handle_remove_resource(name, ResourceType.AGENT, "agents", global_install)
+        return
+
+    # Normal unified remove: agr remove <name>
+    name = first_arg
+    handle_remove_unified(name, resource_type, global_install)