taken-cli 0.1.0__py3-none-any.whl

taken/commands/add.py

@@ -0,0 +1,214 @@
+import re
+from datetime import datetime
+from pathlib import Path
+
+import typer
+from rich.panel import Panel
+
+from taken.core import paths
+from taken.core.config import is_config_exists, read_config
+from taken.core.editor import open_in_editor
+from taken.core.git import auto_commit_and_push
+from taken.core.registry import read_registry, write_registry
+from taken.core.skills import (
+    adopt_skill,
+    is_path_argument,
+    lookup_lock_entry,
+    scaffold_skill,
+)
+from taken.models.config import TakenConfig
+from taken.models.registry import RegistryEntry, SkillSource
+from taken.utils.console import console, err_console
+
+_VALID_NAME = re.compile(r"^[a-zA-Z0-9][a-zA-Z0-9_-]*$")
+
+
+def add(
+    skill_or_path: str = typer.Argument(..., help="Skill name to create, or path to existing skill folder to adopt"),
+) -> None:
+    """Add a new personal skill or adopt an existing skill into taken management."""
+    if not is_config_exists(paths.TAKEN_HOME):
+        err_console.print(
+            Panel(
+                "Taken is not initialized. Run [bold]taken init[/bold] to get started.",
+                title="[red]Not Initialized[/red]",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(code=1)
+
+    config = read_config(paths.TAKEN_HOME)
+
+    if is_path_argument(skill_or_path):
+        _adopt_mode(skill_or_path, config)
+    else:
+        _create_mode(skill_or_path, config)
+
+
+def _create_mode(name: str, config: TakenConfig) -> None:
+    if "/" in name:
+        err_console.print(
+            Panel(
+                f"Skill name must not contain a namespace. Got: [bold]{name}[/bold]\n"
+                f"Your namespace [bold]{config.username}[/bold] is added automatically.\n"
+                "Example: [bold]taken add my-skill[/bold]",
+                title="[red]Invalid Skill Name[/red]",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(code=1)
+
+    if not _VALID_NAME.match(name):
+        err_console.print(
+            Panel(
+                f"[bold]{name}[/bold] is not a valid skill name.\n"
+                "Use lowercase letters, numbers, hyphens, and underscores only.\n"
+                "Must start with a letter or number.",
+                title="[red]Invalid Skill Name[/red]",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(code=1)
+
+    registry = read_registry(paths.TAKEN_HOME)
+    full_name = f"{config.username}/{name}"
+
+    if registry.exists(full_name):
+        err_console.print(
+            Panel(
+                f"Skill [bold]{full_name}[/bold] is already in your registry.\nUse [bold]taken list[/bold] to see it.",
+                title="[red]Already Exists[/red]",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(code=1)
+
+    try:
+        skill_md = scaffold_skill(config.username, name, paths.TAKEN_HOME)
+    except FileExistsError:
+        err_console.print(
+            Panel(
+                f"Skill directory already exists on disk but is not in the registry.\n"
+                f"Path: [dim]{paths.TAKEN_HOME}/skills/{config.username}/{name}[/dim]\n"
+                "Run [bold]taken doctor[/bold] to repair registry drift.",
+                title="[red]Directory Conflict[/red]",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(code=1) from None
+
+    now = datetime.now()
+    entry = RegistryEntry(
+        namespace=config.username,
+        name=name,
+        source=SkillSource.PERSONAL,
+        version="1",
+        created_at=now,
+        updated_at=now,
+    )
+    registry.add(entry)
+    write_registry(registry, paths.TAKEN_HOME)
+    auto_commit_and_push(paths.TAKEN_HOME, f"add: {full_name}")
+
+    console.print(
+        Panel(
+            f"[green]✓[/green] Created [bold]{full_name}[/bold]\n"
+            f"[green]✓[/green] Registered as [bold]personal[/bold] skill\n\n"
+            f"[dim]Opening editor…[/dim]",
+            title="[green]Skill Created[/green]",
+            border_style="green",
+            padding=(1, 2),
+        )
+    )
+
+    open_in_editor(skill_md)
+
+
+def _adopt_mode(path_str: str, config: TakenConfig) -> None:
+    source_dir = Path(path_str).resolve()
+
+    if not source_dir.is_dir():
+        err_console.print(
+            Panel(
+                f"[bold]{path_str}[/bold] is not a directory.",
+                title="[red]Invalid Path[/red]",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(code=1)
+
+    name = source_dir.name
+    lock_entry = lookup_lock_entry(name, Path.cwd())
+
+    if lock_entry is not None:
+        namespace = lock_entry.source.split("/")[0]
+        source = SkillSource.NPX
+        repo = lock_entry.source
+        version = lock_entry.ref
+        source_url = lock_entry.source_url
+        skill_path = lock_entry.skill_path
+        skill_folder_hash = lock_entry.skill_folder_hash
+    else:
+        namespace = config.username
+        source = SkillSource.PERSONAL
+        repo = None
+        version = None
+        source_url = None
+        skill_path = None
+        skill_folder_hash = None
+
+    registry = read_registry(paths.TAKEN_HOME)
+    full_name = f"{namespace}/{name}"
+
+    if registry.exists(full_name):
+        err_console.print(
+            Panel(
+                f"Skill [bold]{full_name}[/bold] is already in your registry.\nUse [bold]taken list[/bold] to see it.",
+                title="[red]Already Exists[/red]",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(code=1)
+
+    try:
+        adopt_skill(source_dir, namespace, name, paths.TAKEN_HOME)
+    except FileExistsError:
+        err_console.print(
+            Panel(
+                f"Skill directory already exists at [dim]{paths.TAKEN_HOME}/skills/{namespace}/{name}[/dim]\n"
+                "Run [bold]taken doctor[/bold] to repair registry drift.",
+                title="[red]Directory Conflict[/red]",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(code=1) from None
+
+    now = datetime.now()
+    entry = RegistryEntry(
+        namespace=namespace,
+        name=name,
+        source=source,
+        repo=repo,
+        version=version,
+        installed_at=now if source == SkillSource.NPX else None,
+        created_at=now if source == SkillSource.PERSONAL else None,
+        updated_at=now,
+        source_url=source_url,
+        skill_path=skill_path,
+        skill_folder_hash=skill_folder_hash,
+    )
+    registry.add(entry)
+    write_registry(registry, paths.TAKEN_HOME)
+    auto_commit_and_push(paths.TAKEN_HOME, f"add: {full_name}")
+
+    source_detail = f" ({repo})" if repo else ""
+    console.print(
+        Panel(
+            f"[green]✓[/green] Adopted [bold]{name}[/bold] → [bold]{full_name}[/bold]\n"
+            f"[green]✓[/green] Source: [bold]{source.value}[/bold]{source_detail}\n\n"
+            f"[dim]Copied to ~/.taken/skills/{namespace}/{name}/[/dim]",
+            title="[green]Skill Adopted[/green]",
+            border_style="green",
+            padding=(1, 2),
+        )
+    )

taken/commands/git.py

@@ -0,0 +1,10 @@
+import typer
+
+from taken.core import paths
+from taken.core.git import run_passthrough
+
+
+def git(ctx: typer.Context) -> None:
+    """Run a git command in the taken home directory (~/.taken/)."""
+    returncode = run_passthrough(paths.TAKEN_HOME, ctx.args)
+    raise SystemExit(returncode)

taken/commands/init.py

@@ -0,0 +1,171 @@
+import shutil
+import subprocess
+from datetime import datetime
+
+import typer
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+
+from taken.core import paths
+from taken.core.config import is_config_exists, write_config
+from taken.core.git import init_repo
+from taken.core.registry import write_registry
+from taken.models.config import TakenConfig
+from taken.models.registry import Registry
+from taken.utils.console import console, err_console
+
+
+def _resolve_username() -> str:
+    """
+    Prompt the user to choose their namespace username via sequential prompts.
+    Options: system username, git config name, or manual override.
+    """
+    # Gather candidates
+    import getpass
+
+    whoami = getpass.getuser()
+
+    git_name: str | None = None
+    try:
+        result = subprocess.run(
+            ["git", "config", "user.name"],
+            capture_output=True,
+            text=True,
+            timeout=3,
+        )
+        git_name = result.stdout.strip() or None
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        git_name = None
+
+    # Present options
+    console.print("\n[bold]Choose your skill namespace username:[/bold]")
+    console.print(f"  [cyan]1[/cyan]  System username   → [green]{whoami}[/green]")
+
+    if git_name:
+        console.print(f"  [cyan]2[/cyan]  Git config name  → [green]{git_name}[/green]")
+        console.print("  [cyan]3[/cyan]  Enter manually")
+    else:
+        console.print("  [cyan]2[/cyan]  Enter manually   [dim](git config name not found)[/dim]")
+
+    choice = Prompt.ask(
+        "\nPick an option",
+        choices=["1", "2", "3"] if git_name else ["1", "2"],
+        default="1",
+    )
+
+    if choice == "1":
+        return whoami
+    elif choice == "2" and git_name:
+        return git_name
+    else:
+        # Manual override
+        username = Prompt.ask("Enter your username").strip()
+        if not username:
+            err_console.print(
+                Panel(
+                    "Username cannot be empty.",
+                    title="[red]Error[/red]",
+                    border_style="red",
+                )
+            )
+            raise typer.Exit(code=1)
+        return username
+
+
+def _handle_existing_init() -> bool:
+    """
+    Handle the case where ~/.taken/ already exists.
+    Prompts user to choose between resetting config only or full wipe.
+    Returns True if we should proceed, False if user aborted.
+    """
+    err_console.print(
+        Panel(
+            "[yellow]Taken is already initialized at[/yellow] [bold]~/.taken/[/bold]\n\n"
+            "Reinitializing will overwrite your config. Choose carefully.",
+            title="[yellow]Already Initialized[/yellow]",
+            border_style="yellow",
+        )
+    )
+
+    proceed = Confirm.ask("Do you want to reinitialize?", default=False)
+    if not proceed:
+        console.print("[dim]Aborted. Nothing was changed.[/dim]")
+        return False
+
+    # Give user two options
+    console.print("\n[bold]What would you like to reset?[/bold]")
+    console.print("  [cyan]1[/cyan]  Reset config only  [dim](keeps your skills and registry intact)[/dim]")
+    console.print("  [cyan]2[/cyan]  Full wipe          [dim](deletes everything — skills, registry, config)[/dim]")
+
+    choice = Prompt.ask("\nPick an option", choices=["1", "2"], default="1")
+
+    if choice == "2":
+        confirm_wipe = Confirm.ask(
+            "[red]This will delete ALL your skills and registry. Are you sure?[/red]",
+            default=False,
+        )
+        if not confirm_wipe:
+            console.print("[dim]Aborted. Nothing was changed.[/dim]")
+            return False
+
+        # Full wipe — delete ~/.taken/ entirely
+        shutil.rmtree(paths.TAKEN_HOME)
+        console.print("[dim]Wiped ~/.taken/ — starting fresh.[/dim]")
+
+    # Reset config only — just let init proceed and overwrite config.yaml
+    return True
+
+
+def init() -> None:
+    """
+    Initialize Taken — sets up ~/.taken/ with config.yaml and registry.yaml.
+    """
+    console.print(
+        Panel(
+            "[bold white]Welcome to Taken[/bold white]\n[dim]A very particular set of skills, managed.[/dim]",
+            border_style="bright_blue",
+            padding=(1, 4),
+        )
+    )
+
+    # Handle existing init
+    if is_config_exists(paths.TAKEN_HOME):
+        should_proceed = _handle_existing_init()
+        if not should_proceed:
+            raise typer.Exit(code=0)
+
+    # Resolve username
+    username = _resolve_username()
+
+    # Create directory structure
+    skills_dir = paths.TAKEN_HOME / "skills" / username
+    skills_dir.mkdir(parents=True, exist_ok=True)
+
+    # Write config
+    config = TakenConfig(
+        username=username,
+        taken_home=paths.TAKEN_HOME,
+        initialized_at=datetime.now(),
+    )
+    write_config(config)
+
+    # Write empty registry (only if it doesn't exist — preserve existing on config-only reset)
+    from taken.core.registry import is_registry_exists
+
+    if not is_registry_exists(paths.TAKEN_HOME):
+        write_registry(Registry(), paths.TAKEN_HOME)
+
+    # Initialize git repo and make initial commit
+    init_repo(paths.TAKEN_HOME)
+
+    # Success
+    console.print(
+        Panel(
+            f"[green]✓[/green] Initialized at [bold]~/.taken/[/bold]\n"
+            f"[green]✓[/green] Username set to [bold]{username}[/bold]\n\n"
+            f"[dim]Your personal skills namespace: [bold]{username}/<skill-name>[/bold][/dim]",
+            title="[green]Taken Initialized[/green]",
+            border_style="green",
+            padding=(1, 2),
+        )
+    )

taken/commands/install.py

@@ -0,0 +1,227 @@
+import shutil
+from datetime import datetime
+
+import typer
+from InquirerPy import inquirer
+from InquirerPy.enum import INQUIRERPY_EMPTY_CIRCLE_SEQUENCE, INQUIRERPY_FILL_CIRCLE_SEQUENCE
+from rich.panel import Panel
+
+from taken.core import paths
+from taken.core.config import is_config_exists
+from taken.core.git import auto_commit_and_push
+from taken.core.github import (
+    GitHubSkill,
+    discover_skills,
+    download_skill,
+    get_commit_sha,
+    get_default_branch,
+    normalize_source,
+    parse_source,
+)
+from taken.core.registry import read_registry, write_registry
+from taken.models.registry import RegistryEntry, SkillSource, VersionPin
+from taken.utils.console import console, err_console
+
+
+def _select_skills(skills: list[GitHubSkill]) -> list[GitHubSkill]:
+    if len(skills) == 1:
+        return skills
+
+    choices = [{"name": s.name, "value": s} for s in skills]
+    selected: list[GitHubSkill] = inquirer.fuzzy(  # type: ignore[attr-defined]
+        message="Select skills to install:",
+        choices=choices,
+        multiselect=True,
+        marker=INQUIRERPY_FILL_CIRCLE_SEQUENCE,
+        marker_pl=INQUIRERPY_EMPTY_CIRCLE_SEQUENCE,
+        instruction="(type to filter  space/tab to select  enter to confirm)",
+        keybindings={"toggle": [{"key": "space"}, {"key": "tab"}]},
+        validate=lambda x: len(x) > 0,
+        invalid_message="Select at least one skill.",
+    ).execute()
+    return selected
+
+
+def _filter_skills(
+    skills: list[GitHubSkill],
+    skill_filter: list[str],
+    owner: str,
+    repo: str,
+) -> list[GitHubSkill]:
+    """Apply name filter; raises typer.Exit(1) if no skills match."""
+    if not skill_filter:
+        return skills
+    filtered = [s for s in skills if s.name in skill_filter]
+    if not filtered:
+        available = ", ".join(s.name for s in skills)
+        err_console.print(
+            Panel(
+                f"No skill named [bold]{', '.join(skill_filter)}[/bold] found in [bold]{owner}/{repo}[/bold].\n"
+                f"Available: [dim]{available}[/dim]",
+                title="[red]Skill Not Found[/red]",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(code=1)
+    return filtered
+
+
+def _print_install_results(
+    installed: list[str],
+    skipped: list[str],
+    owner: str,
+    repo: str,
+    sha: str,
+    pin: bool,
+) -> None:
+    if installed:
+        lines = "\n".join(f"[green]✓[/green] [bold]{n}[/bold]" for n in installed)
+        lines += f"\n\n[dim]{owner}/{repo} @ {sha[:8]}[/dim]"
+        if pin:
+            lines += "\n[dim]Pinned to commit[/dim]"
+        console.print(Panel(lines, title="[green]Skills Installed[/green]", border_style="green", padding=(1, 2)))
+    if skipped:
+        console.print(f"[dim]Already in registry (skipped): {', '.join(skipped)}[/dim]")
+    if not installed and not skipped:
+        console.print("[dim]Nothing installed.[/dim]")
+
+
+def _fetch_github_skills(owner: str, repo: str, ref: str) -> tuple[str, list[GitHubSkill]]:
+    """Resolve ref to a commit SHA and discover skills in the repo."""
+    resolved_ref = ref if ref else get_default_branch(owner, repo)
+    sha = get_commit_sha(owner, repo, resolved_ref)
+    skills = discover_skills(owner, repo, sha)
+    return sha, skills
+
+
+def _install_skills(
+    selected: list[GitHubSkill],
+    owner: str,
+    repo: str,
+    sha: str,
+    pin: bool,
+) -> tuple[list[str], list[str]]:
+    """Download and register each selected skill; return (installed, skipped)."""
+    registry = read_registry(paths.TAKEN_HOME)
+    installed: list[str] = []
+    skipped: list[str] = []
+
+    for gh_skill in selected:
+        full_name = f"{owner}/{gh_skill.name}"
+        dest = paths.TAKEN_HOME / "skills" / owner / gh_skill.name
+
+        if registry.exists(full_name) or dest.exists():
+            skipped.append(full_name)
+            continue
+
+        try:
+            with console.status(f"[dim]Downloading {full_name}…[/dim]"):
+                download_skill(owner, repo, gh_skill.skill_path, sha, dest)
+        except Exception as e:
+            err_console.print(Panel(str(e), title=f"[red]Failed: {full_name}[/red]", border_style="red"))
+            if dest.exists():
+                shutil.rmtree(dest)
+            continue
+
+        now = datetime.now()
+        entry = RegistryEntry(
+            namespace=owner,
+            name=gh_skill.name,
+            source=SkillSource.TAKEN,
+            repo=f"{owner}/{repo}",
+            version=sha,
+            pin=VersionPin.PINNED if pin else VersionPin.FLOATING,
+            installed_at=now,
+            updated_at=now,
+            source_url=f"https://github.com/{owner}/{repo}",
+            skill_path=gh_skill.skill_path or None,
+            skill_folder_hash=gh_skill.skill_folder_hash or None,
+        )
+        registry.add(entry)
+        installed.append(full_name)
+
+    if installed:
+        write_registry(registry, paths.TAKEN_HOME)
+
+    return installed, skipped
+
+
+def install(
+    source: str = typer.Argument(
+        ...,
+        metavar="source",
+        help="GitHub repo, URL, or npx skills add command. E.g. vercel-labs/agent-skills",
+    ),
+    skill: list[str] = typer.Option(  # noqa: B008
+        [],
+        "--skill",
+        "-s",
+        help="Skill name(s) to install (repeatable). Alternative to owner/repo/skill path form.",
+    ),
+    ref: str = typer.Option(
+        "", "--ref", metavar="REF", help="Branch, tag, or commit SHA (default: repo default branch)."
+    ),
+    pin: bool = typer.Option(False, "--pin", help="Pin to the exact commit SHA."),
+) -> None:
+    """Install one or more skills from a GitHub repository."""
+    if not is_config_exists(paths.TAKEN_HOME):
+        err_console.print(
+            Panel(
+                "Taken is not initialized. Run [bold]taken init[/bold] to get started.",
+                title="[red]Not Initialized[/red]",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(code=1)
+
+    try:
+        normalized = normalize_source(source)
+        owner, repo, path_filter = parse_source(normalized)
+    except ValueError as e:
+        err_console.print(Panel(str(e), title="[red]Invalid Source[/red]", border_style="red"))
+        raise typer.Exit(code=1) from None
+
+    # Merge skill selection: --skill flag wins; path filter is fallback; empty = all
+    skill_filter: list[str] = list(skill) or ([path_filter] if path_filter else [])
+
+    try:
+        with console.status("[dim]Contacting GitHub…[/dim]"):
+            sha, skills = _fetch_github_skills(owner, repo, ref)
+    except FileNotFoundError:
+        err_console.print(
+            Panel(
+                f"Repository [bold]{owner}/{repo}[/bold] not found on GitHub.\nCheck the name and try again.",
+                title="[red]Not Found[/red]",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(code=1) from None
+    except PermissionError as e:
+        err_console.print(
+            Panel(
+                f"{e}\n\nTip: set [bold]GITHUB_TOKEN[/bold] in your environment for higher rate limits.",
+                title="[red]GitHub API Error[/red]",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(code=1) from e
+    except Exception as e:
+        err_console.print(Panel(str(e), title="[red]Error[/red]", border_style="red"))
+        raise typer.Exit(code=1) from e
+
+    if not skills:
+        err_console.print(
+            Panel(
+                f"No skills (SKILL.md files) found in [bold]{owner}/{repo}[/bold].",
+                title="[red]No Skills Found[/red]",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(code=1)
+
+    skills = _filter_skills(skills, skill_filter, owner, repo)
+    selected = skills if skill_filter else _select_skills(skills)
+    installed, skipped = _install_skills(selected, owner, repo, sha, pin)
+    if installed:
+        auto_commit_and_push(paths.TAKEN_HOME, f"install: {' '.join(installed)}")
+    _print_install_results(installed, skipped, owner, repo, sha, pin)

taken/commands/list.py

@@ -0,0 +1,57 @@
+import typer
+from rich.box import SIMPLE
+from rich.panel import Panel
+from rich.table import Table
+
+from taken.core import paths
+from taken.core.config import is_config_exists
+from taken.core.registry import read_registry
+from taken.models.registry import SkillSource
+from taken.utils.console import console, err_console
+
+_SOURCE_STYLE: dict[SkillSource, str] = {
+    SkillSource.PERSONAL: "green",
+    SkillSource.NPX: "blue",
+    SkillSource.TAKEN: "magenta",
+}
+
+
+def list() -> None:
+    """List all skills in the registry."""
+    if not is_config_exists(paths.TAKEN_HOME):
+        err_console.print(
+            Panel(
+                "Taken is not initialized. Run [bold]taken init[/bold] to get started.",
+                title="[red]Not Initialized[/red]",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(code=1)
+
+    registry = read_registry(paths.TAKEN_HOME)
+
+    if not registry.skills:
+        console.print("[yellow]No skills registered yet. Use [bold]taken add[/bold] to create one.[/yellow]")
+        return
+
+    table = Table(show_header=True, header_style="bold", box=SIMPLE, padding=(0, 1))
+    table.add_column("Skill", style="bold cyan", no_wrap=True)
+    table.add_column("Source")
+    table.add_column("Version")
+    table.add_column("Date")
+
+    for entry in sorted(registry.skills.values(), key=lambda e: e.full_name):
+        style = _SOURCE_STYLE.get(entry.source, "")
+        version = entry.version[:8] if entry.version else "—"
+        date = entry.created_at or entry.installed_at
+        date_str = date.strftime("%Y-%m-%d") if date else "—"
+        table.add_row(
+            entry.full_name,
+            f"[{style}]{entry.source.value}[/{style}]",
+            version,
+            date_str,
+        )
+
+    console.print(table)
+    count = len(registry.skills)
+    console.print(f"[dim]{count} skill{'s' if count != 1 else ''}[/dim]")