taken-cli 0.2.0__tar.gz → 0.2.2__tar.gz

{taken_cli-0.2.0 → taken_cli-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: taken-cli
-Version: 0.2.0
+Version: 0.2.2
 Summary: Personal dotfile-style CLI for managing AI agent skills
 Author: Pradyoth
 Author-email: Pradyoth <pradyoth.dev@gmail.com>
@@ -85,7 +85,7 @@ Interactive fuzzy picker when multiple skills are found. Key flags:
 ```bash
 taken use
 ```
-Fuzzy-picks from your registry, copies the skill into `.agents/skills/` in the current project, and mirrors it into `.claude/skills/` (symlink or copy, your choice). Tracking lives in `~/.taken/projects.yaml` — nothing taken-specific is written into the project.
+Fuzzy-picks from your registry, copies the skill into `.agents/skills/` in the current project, and asks which agent folders (`.claude/skills/`, `.cursor/skills/`, ...) to symlink or copy it into, then shows every link it made. Tracking lives in `~/.taken/projects.yaml` — nothing taken-specific is written into the project.
 
 **6. Push edits back to registry**
 ```bash
@@ -114,6 +114,7 @@ Re-copies the latest registry version into the project. Warns before overwriting
 | `taken update [namespace/skill]` | Re-copy latest registry version into project |
 | `taken list` | Show all skills in the registry |
 | `taken remove <namespace/skill>` | Remove a skill from registry |
+| `taken mirrors list\|add\|remove` | Manage the agent folders `taken use` links into |
 | `taken git <args>` | Run any git command inside `~/.taken/` |
 
 ---

{taken_cli-0.2.0 → taken_cli-0.2.2}/README.md

@@ -65,7 +65,7 @@ Interactive fuzzy picker when multiple skills are found. Key flags:
 ```bash
 taken use
 ```
-Fuzzy-picks from your registry, copies the skill into `.agents/skills/` in the current project, and mirrors it into `.claude/skills/` (symlink or copy, your choice). Tracking lives in `~/.taken/projects.yaml` — nothing taken-specific is written into the project.
+Fuzzy-picks from your registry, copies the skill into `.agents/skills/` in the current project, and asks which agent folders (`.claude/skills/`, `.cursor/skills/`, ...) to symlink or copy it into, then shows every link it made. Tracking lives in `~/.taken/projects.yaml` — nothing taken-specific is written into the project.
 
 **6. Push edits back to registry**
 ```bash
@@ -94,6 +94,7 @@ Re-copies the latest registry version into the project. Warns before overwriting
 | `taken update [namespace/skill]` | Re-copy latest registry version into project |
 | `taken list` | Show all skills in the registry |
 | `taken remove <namespace/skill>` | Remove a skill from registry |
+| `taken mirrors list\|add\|remove` | Manage the agent folders `taken use` links into |
 | `taken git <args>` | Run any git command inside `~/.taken/` |
 
 ---

{taken_cli-0.2.0 → taken_cli-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "taken-cli"
-version = "0.2.0"
+version = "0.2.2"
 description = "Personal dotfile-style CLI for managing AI agent skills"
 readme = "README.md"
 requires-python = ">=3.11"

{taken_cli-0.2.0 → taken_cli-0.2.2}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "taken-cli"
-version = "0.2.0"
+version = "0.2.2"
 description = "Personal dotfile-style CLI for managing AI agent skills"
 readme = "README.md"
 license = { text = "MIT" }

taken_cli-0.2.2/src/taken/commands/mirrors.py

@@ -0,0 +1,95 @@
+import typer
+from rich.panel import Panel
+
+from taken.core import paths
+from taken.core.config import is_config_exists, normalize_mirror_dir, read_config, write_config
+from taken.core.git import auto_commit_and_push
+from taken.models.config import TakenConfig
+from taken.utils.console import console, err_console
+
+mirrors_app = typer.Typer(
+    help="Manage the agent dirs (e.g. .claude/skills) that `taken use` can link skills into.",
+    no_args_is_help=True,
+)
+
+
+def _load_config() -> TakenConfig:
+    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)
+    return read_config(paths.TAKEN_HOME)
+
+
+def _normalize_or_exit(raw: str, config: TakenConfig) -> str:
+    try:
+        return normalize_mirror_dir(raw, config.skills.main_dir)
+    except ValueError as e:
+        err_console.print(Panel(str(e), title="[red]Invalid Mirror Dir[/red]", border_style="red"))
+        raise typer.Exit(code=1) from e
+
+
+@mirrors_app.command("list")
+def list_mirrors() -> None:
+    """Show the main skills dir, mirror mode, and the mirror dirs offered by `taken use`."""
+    config = _load_config()
+    skills = config.skills
+    console.print(f"[bold]Main dir:[/bold]    {skills.main_dir}")
+    console.print(f"[bold]Mirror mode:[/bold] {skills.mirror_mode.value}")
+    if not skills.mirror_dirs:
+        console.print("[bold]Mirror dirs:[/bold] [dim]none — add one with[/dim] [bold]taken mirrors add <dir>[/bold]")
+        return
+    console.print("[bold]Mirror dirs:[/bold]")
+    for d in skills.mirror_dirs:
+        console.print(f"  • {d}")
+
+
+@mirrors_app.command("add")
+def add_mirror(
+    directory: str = typer.Argument(..., help="Dir relative to the project root, e.g. .cursor/skills"),
+) -> None:
+    """Add a mirror dir that `taken use` will offer."""
+    config = _load_config()
+    normalized = _normalize_or_exit(directory, config)
+
+    if normalized in config.skills.mirror_dirs:
+        console.print(f"[dim]{normalized} is already in your mirror list.[/dim]")
+        return
+
+    config.skills.mirror_dirs.append(normalized)
+    write_config(config)
+    auto_commit_and_push(paths.TAKEN_HOME, f"mirrors: add {normalized}")
+    console.print(f"[green]✓[/green] Added [bold]{normalized}[/bold] — `taken use` will offer it from now on.")
+
+
+@mirrors_app.command("remove")
+def remove_mirror(
+    directory: str = typer.Argument(..., help="Mirror dir to stop offering, e.g. .cursor/skills"),
+) -> None:
+    """Stop offering a mirror dir. Existing links in projects are left in place."""
+    config = _load_config()
+    normalized = _normalize_or_exit(directory, config)
+
+    if normalized not in config.skills.mirror_dirs:
+        err_console.print(
+            Panel(
+                f"[bold]{normalized}[/bold] is not in your mirror list.\n"
+                "Run [bold]taken mirrors list[/bold] to see it.",
+                title="[red]Not Found[/red]",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(code=1)
+
+    config.skills.mirror_dirs.remove(normalized)
+    write_config(config)
+    auto_commit_and_push(paths.TAKEN_HOME, f"mirrors: remove {normalized}")
+    console.print(
+        f"[green]✓[/green] Removed [bold]{normalized}[/bold].\n"
+        "[dim]Existing links in projects stay; re-run `taken use` in a project to drop them.[/dim]"
+    )

{taken_cli-0.2.0 → taken_cli-0.2.2}/src/taken/commands/save.py

@@ -16,7 +16,13 @@ from taken.core.config import is_config_exists, read_config
 from taken.core.git import auto_commit_and_push
 from taken.core.hashing import compute_skill_hash
 from taken.core.mirror import edited_copies, main_skill_dir, remove_path, sync_mirrors
-from taken.core.project import is_project_config_exists, read_project_config, resolve_layout, write_project_config
+from taken.core.project import (
+    is_project_config_exists,
+    read_project_config,
+    resolve_layout,
+    skill_layout,
+    write_project_config,
+)
 from taken.core.registry import read_registry, write_registry
 from taken.models.project import ProjectConfig, ProjectSkillEntry, SkillLayout
 from taken.models.registry import Registry
@@ -93,6 +99,7 @@ def _process_skill(
     registry_skill_dir = paths.TAKEN_HOME / "skills" / namespace / name
 
     existing = project_config.skills[full_name]
+    layout = skill_layout(layout, existing)
     edited = edited_copies(project_root, layout, name, existing.copied_hash)
 
     if not edited:
@@ -115,6 +122,7 @@ def _process_skill(
     project_config.skills[full_name] = ProjectSkillEntry(
         copied_at=existing.copied_at,
         copied_hash=new_hash,
+        mirror_dirs=existing.mirror_dirs,
     )
 
     registry_entry = registry.get(full_name)

{taken_cli-0.2.0 → taken_cli-0.2.2}/src/taken/commands/update.py

@@ -18,7 +18,13 @@ from taken.core.git import auto_commit_and_push
 from taken.core.github import discover_skills, download_skill, get_commit_sha, get_default_branch
 from taken.core.hashing import compute_skill_hash
 from taken.core.mirror import edited_copies, main_skill_dir, remove_path, sync_mirrors
-from taken.core.project import is_project_config_exists, read_project_config, resolve_layout, write_project_config
+from taken.core.project import (
+    is_project_config_exists,
+    read_project_config,
+    resolve_layout,
+    skill_layout,
+    write_project_config,
+)
 from taken.core.registry import read_registry, write_registry
 from taken.models.project import ProjectConfig, ProjectSkillEntry, SkillLayout
 from taken.models.registry import Registry, RegistryEntry, SkillSource, VersionPin
@@ -148,6 +154,7 @@ def _process_skill(
         raise typer.Exit(code=1)
 
     existing = project_config.skills[full_name]
+    layout = skill_layout(layout, existing)
     registry_hash = compute_skill_hash(registry_skill_dir)
     registry_changed = registry_hash != existing.copied_hash
     project_edited = bool(edited_copies(project_root, layout, name, existing.copied_hash))
@@ -169,15 +176,18 @@ def _process_skill(
     project_skill_dir.parent.mkdir(parents=True, exist_ok=True)
     remove_path(project_skill_dir)
     shutil.copytree(registry_skill_dir, project_skill_dir)
-    for dst in sync_mirrors(project_root, layout, name):
-        err_console.print(
-            f"[yellow]⚠[/yellow]  Could not symlink [bold]{dst.relative_to(project_root)}[/bold] — copied instead."
-        )
+    for result in sync_mirrors(project_root, layout, name):
+        if result.fell_back:
+            err_console.print(
+                f"[yellow]⚠[/yellow]  Could not symlink [bold]{result.path.relative_to(project_root)}[/bold] "
+                "— copied instead."
+            )
 
     new_hash = compute_skill_hash(project_skill_dir)
     project_config.skills[full_name] = ProjectSkillEntry(
         copied_at=existing.copied_at,
         copied_hash=new_hash,
+        mirror_dirs=existing.mirror_dirs,
     )
 
     updated.append(f"[green]✓[/green] [bold]{full_name}[/bold] → {layout.main_dir}/{name}/")

taken_cli-0.2.2/src/taken/commands/use.py

@@ -0,0 +1,315 @@
+import shutil
+import sys
+from datetime import datetime
+from pathlib import Path
+
+import typer
+from InquirerPy import inquirer
+from InquirerPy.base.control import Choice
+from InquirerPy.enum import (
+    INQUIRERPY_EMPTY_CIRCLE_SEQUENCE,
+    INQUIRERPY_FILL_CIRCLE_SEQUENCE,
+)
+from rich.panel import Panel
+from rich.prompt import Confirm
+
+from taken.core import paths
+from taken.core.config import is_config_exists, normalize_mirror_dir, read_config
+from taken.core.hashing import compute_skill_hash
+from taken.core.mirror import (
+    MirrorResult,
+    edited_copies,
+    main_skill_dir,
+    remove_path,
+    remove_unselected_mirrors,
+    sync_mirrors,
+    untracked_paths,
+)
+from taken.core.project import read_project_config, resolve_layout, skill_layout, write_project_config
+from taken.core.registry import read_registry
+from taken.models.config import MirrorMode
+from taken.models.project import ProjectConfig, ProjectSkillEntry, SkillLayout
+from taken.models.registry import Registry, RegistryEntry
+from taken.utils.console import console, err_console
+
+
+def _resolve_selected(
+    namespace_skill: str | None,
+    registry: Registry,
+) -> list[RegistryEntry]:
+    """Return the list of skills the user chose; raises typer.Exit on invalid input."""
+    if namespace_skill is not None:
+        entry = registry.get(namespace_skill)
+        if entry is None:
+            err_console.print(
+                Panel(
+                    f"[bold]{namespace_skill}[/bold] not found in registry.\n"
+                    "Run [bold]taken list[/bold] to see available skills.",
+                    title="[red]Skill Not Found[/red]",
+                    border_style="red",
+                )
+            )
+            raise typer.Exit(code=1)
+        return [entry]
+
+    choices = [
+        {"name": f"{e.full_name}  [{e.source.value}]", "value": e.full_name}
+        for e in sorted(registry.skills.values(), key=lambda e: e.full_name)
+    ]
+    selected_names: list[str] = inquirer.fuzzy(  # type: ignore[attr-defined]
+        message="Search skills:",
+        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()
+
+    if not selected_names:
+        raise typer.Exit(code=0)
+
+    return [e for name in selected_names if (e := registry.get(name)) is not None]
+
+
+def use(
+    namespace_skill: str | None = typer.Argument(
+        None,
+        help="Skill to copy into project, e.g. pradyothsp/hello-world. Omit for interactive picker.",
+    ),
+    mode: MirrorMode | None = typer.Option(  # noqa: B008
+        None,
+        "--mode",
+        help="How to mirror into extra dirs like .claude/skills (symlink or copy). Remembered for this project.",
+        case_sensitive=False,
+    ),
+    mirror: list[str] = typer.Option(  # noqa: B008
+        [],
+        "--mirror",
+        "-m",
+        help="Mirror dir to link into (repeatable). Skips the prompt. Must be in `taken mirrors list`.",
+    ),
+    no_mirror: bool = typer.Option(
+        False,
+        "--no-mirror",
+        help="Don't mirror into any agent dir. Skips the prompt.",
+    ),
+) -> None:
+    """Copy skill(s) from ~/.taken/ into the current project's skills dir and mirror them to agent dirs."""
+    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:
+        err_console.print(
+            Panel(
+                "No skills in your registry yet. Run [bold]taken add[/bold] to create one.",
+                title="[red]Registry Empty[/red]",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(code=1)
+
+    selected = _resolve_selected(namespace_skill, registry)
+
+    project_root = Path.cwd()
+    project_config = read_project_config(project_root)
+    if mode is not None:
+        project_config.mirror_mode = mode
+    layout = resolve_layout(read_config(paths.TAKEN_HOME), project_config)
+
+    chosen_dirs = _resolve_mirror_dirs(mirror, no_mirror, layout, selected, project_config)
+    new_layout = layout.model_copy(update={"mirror_dirs": tuple(chosen_dirs)})
+
+    now = datetime.now()
+    copied: list[str] = []
+    skipped: list[str] = []
+
+    for entry in selected:
+        existing = project_config.skills.get(entry.full_name)
+        prev_layout = skill_layout(layout, existing)
+        if not _confirm_overwrite(entry, project_root, prev_layout, new_layout, existing):
+            skipped.append(entry.full_name)
+            continue
+
+        candidate_dirs = list(dict.fromkeys([*layout.mirror_dirs, *prev_layout.mirror_dirs]))
+        removed = remove_unselected_mirrors(
+            project_root,
+            new_layout,
+            candidate_dirs,
+            entry.name,
+            existing.copied_hash if existing else None,
+        )
+        results = _copy_skill(entry, project_root, new_layout, project_config, now)
+        copied.append(_describe_copy(entry, project_root, new_layout, results, removed))
+
+    if not copied and not skipped:
+        return
+
+    write_project_config(project_config, project_root)
+
+    if copied:
+        lines = "\n\n".join(copied) + "\n\n[dim]Tracked in ~/.taken/projects.yaml[/dim]"
+        console.print(
+            Panel(
+                lines,
+                title="[green]Skills Added[/green]",
+                border_style="green",
+                padding=(1, 2),
+            )
+        )
+    if skipped:
+        console.print(f"[dim]Skipped: {', '.join(skipped)}[/dim]")
+
+
+def _is_interactive() -> bool:
+    return sys.stdin.isatty() and sys.stdout.isatty()
+
+
+def _default_mirror_dirs(
+    available: list[str],
+    selected: list[RegistryEntry],
+    project_config: ProjectConfig,
+) -> list[str]:
+    """Pre-tick a single already-used skill's previous choice; otherwise everything."""
+    if len(selected) == 1:
+        existing = project_config.skills.get(selected[0].full_name)
+        if existing is not None and existing.mirror_dirs is not None:
+            return [d for d in available if d in existing.mirror_dirs]
+    return available
+
+
+def _resolve_mirror_dirs(
+    mirror: list[str],
+    no_mirror: bool,
+    layout: SkillLayout,
+    selected: list[RegistryEntry],
+    project_config: ProjectConfig,
+) -> list[str]:
+    """Decide which mirror dirs to use: flags first, then the interactive picker, then defaults."""
+    available = list(layout.mirror_dirs)
+
+    if no_mirror:
+        return []
+
+    if mirror:
+        chosen: list[str] = []
+        for raw in mirror:
+            try:
+                normalized = normalize_mirror_dir(raw, layout.main_dir)
+            except ValueError as e:
+                err_console.print(Panel(str(e), title="[red]Invalid Mirror Dir[/red]", border_style="red"))
+                raise typer.Exit(code=1) from e
+            if normalized not in available:
+                err_console.print(
+                    Panel(
+                        f"[bold]{normalized}[/bold] is not in your mirror list.\n"
+                        f"Run [bold]taken mirrors add {normalized}[/bold] first.",
+                        title="[red]Unknown Mirror Dir[/red]",
+                        border_style="red",
+                    )
+                )
+                raise typer.Exit(code=1)
+            chosen.append(normalized)
+        return list(dict.fromkeys(chosen))
+
+    if not available:
+        return []
+
+    preselected = _default_mirror_dirs(available, selected, project_config)
+    if not _is_interactive():
+        return preselected
+
+    verb = "Symlink" if layout.mirror_mode == MirrorMode.SYMLINK else "Copy"
+    picked: list[str] = inquirer.checkbox(  # type: ignore[attr-defined]
+        message=f"{verb} into which folders?",
+        choices=[Choice(value=d, name=d, enabled=d in preselected) for d in available],
+        instruction="(space to toggle, enter to confirm — none is fine)",
+        enabled_symbol=INQUIRERPY_FILL_CIRCLE_SEQUENCE,
+        disabled_symbol=INQUIRERPY_EMPTY_CIRCLE_SEQUENCE,
+    ).execute()
+    return picked
+
+
+def _confirm_overwrite(
+    entry: RegistryEntry,
+    project_root: Path,
+    prev_layout: SkillLayout,
+    new_layout: SkillLayout,
+    existing: ProjectSkillEntry | None,
+) -> bool:
+    """Ask before clobbering local edits or folders taken did not create. Returns True to proceed."""
+    if existing is not None:
+        if edited_copies(project_root, prev_layout, entry.name, existing.copied_hash):
+            console.print(f"\n[yellow]⚠[/yellow]  [bold]{entry.name}[/bold] has local changes in your project.")
+            return Confirm.ask(f"  Overwrite [bold]{entry.name}[/bold]?", default=False)
+        # Only newly chosen dirs can hold something taken didn't create.
+        new_dirs = tuple(d for d in new_layout.mirror_dirs if d not in prev_layout.mirror_dirs)
+        check_layout = new_layout.model_copy(update={"mirror_dirs": new_dirs})
+    else:
+        check_layout = new_layout
+
+    foreign = untracked_paths(project_root, check_layout, entry.name)
+    if foreign:
+        listed = ", ".join(str(p.relative_to(project_root)) for p in foreign)
+        console.print(f"\n[yellow]⚠[/yellow]  [bold]{listed}[/bold] already exists and was not created by taken.")
+        return Confirm.ask(f"  Overwrite with [bold]{entry.full_name}[/bold]?", default=False)
+
+    return True
+
+
+def _describe_copy(
+    entry: RegistryEntry,
+    project_root: Path,
+    layout: SkillLayout,
+    results: list[MirrorResult],
+    removed: list[Path],
+) -> str:
+    main_rel = f"{layout.main_dir}/{entry.name}"
+    lines = [f"[green]✓[/green] [bold]{entry.full_name}[/bold] → {main_rel}/"]
+    for result in results:
+        rel = result.path.relative_to(project_root)
+        if result.is_link:
+            lines.append(f"  [cyan]🔗 {rel}[/cyan] → {main_rel}")
+        elif result.fell_back:
+            lines.append(f"  [yellow]📄 {rel}[/yellow] (copied — symlink not permitted)")
+        else:
+            lines.append(f"  [cyan]📄 {rel}[/cyan] (copy)")
+    lines.extend(f"  [dim]✗ removed {path.relative_to(project_root)}[/dim]" for path in removed)
+    if not results:
+        lines.append("  [dim]not mirrored to any agent dir[/dim]")
+    return "\n".join(lines)
+
+
+def _copy_skill(
+    entry: RegistryEntry,
+    project_root: Path,
+    layout: SkillLayout,
+    project_config: ProjectConfig,
+    now: datetime,
+) -> list[MirrorResult]:
+    """Copy registry skill into the main dir, then mirror it into the layout's dirs."""
+    src = paths.TAKEN_HOME / "skills" / entry.namespace / entry.name
+    dst = main_skill_dir(project_root, layout, entry.name)
+
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    remove_path(dst)
+    shutil.copytree(src, dst)
+    results = sync_mirrors(project_root, layout, entry.name)
+
+    project_config.skills[entry.full_name] = ProjectSkillEntry(
+        copied_at=now,
+        copied_hash=compute_skill_hash(dst),
+        mirror_dirs=list(layout.mirror_dirs),
+    )
+    return results

{taken_cli-0.2.0 → taken_cli-0.2.2}/src/taken/core/config.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from typing import Any, cast
 
 from ruamel.yaml import YAML
@@ -88,3 +88,21 @@ def read_config(taken_home: Path | None = None) -> TakenConfig:
 
 def is_config_exists(taken_home: Path) -> bool:
     return get_config_path(taken_home).exists()
+
+
+def normalize_mirror_dir(raw: str, main_dir: str) -> str:
+    """
+    Validate and normalize a mirror dir (e.g. '.cursor/skills/' -> '.cursor/skills').
+
+    Raises ValueError for absolute paths, parent-dir escapes, or the main skills dir itself.
+    """
+    cleaned = raw.strip().replace("\\", "/")
+    path = PurePosixPath(cleaned)
+    if not cleaned or path.is_absolute() or cleaned.startswith("~"):
+        raise ValueError("Mirror dir must be a path relative to the project root, e.g. .cursor/skills")
+    if ".." in path.parts:
+        raise ValueError("Mirror dir must stay inside the project (no '..').")
+    normalized = str(path)
+    if normalized in (".", str(PurePosixPath(main_dir))):
+        raise ValueError(f"{normalized} is the main skills dir — it can't also be a mirror.")
+    return normalized

{taken_cli-0.2.0 → taken_cli-0.2.2}/src/taken/core/mirror.py

@@ -1,12 +1,21 @@
 import os
 import shutil
 from pathlib import Path
+from typing import NamedTuple
 
 from taken.core.hashing import compute_skill_hash
 from taken.models.config import MirrorMode
 from taken.models.project import SkillLayout
 
 
+class MirrorResult(NamedTuple):
+    """Outcome of mirroring one skill into one mirror dir."""
+
+    path: Path
+    is_link: bool
+    fell_back: bool  # wanted a symlink but had to copy
+
+
 def main_skill_dir(project_root: Path, layout: SkillLayout, name: str) -> Path:
     """The tracked copy of a skill inside the project (e.g. .agents/skills/<name>)."""
     return project_root / layout.main_dir / name
@@ -31,29 +40,64 @@ def remove_path(path: Path) -> None:
         shutil.rmtree(path)
 
 
-def sync_mirrors(project_root: Path, layout: SkillLayout, name: str) -> list[Path]:
+def sync_mirrors(project_root: Path, layout: SkillLayout, name: str) -> list[MirrorResult]:
     """
     Recreate every mirror of a skill from the main copy, using the layout's mirror mode.
 
     Symlinks are relative, so they keep working when the project is moved or cloned.
     If a symlink cannot be created (e.g. Windows without privileges), falls back to a copy.
-    Returns the mirrors that fell back from symlink to copy.
     """
     main = main_skill_dir(project_root, layout, name)
-    fell_back: list[Path] = []
+    results: list[MirrorResult] = []
 
     for dst in mirror_skill_dirs(project_root, layout, name):
         dst.parent.mkdir(parents=True, exist_ok=True)
         remove_path(dst)
+        fell_back = False
         if layout.mirror_mode == MirrorMode.SYMLINK:
             try:
                 dst.symlink_to(os.path.relpath(main, dst.parent), target_is_directory=True)
+                results.append(MirrorResult(path=dst, is_link=True, fell_back=False))
                 continue
             except OSError:
-                fell_back.append(dst)
+                fell_back = True
         shutil.copytree(main, dst)
+        results.append(MirrorResult(path=dst, is_link=False, fell_back=fell_back))
+
+    return results
+
 
-    return fell_back
+def remove_unselected_mirrors(
+    project_root: Path,
+    layout: SkillLayout,
+    candidate_dirs: list[str],
+    name: str,
+    baseline_hash: str | None,
+) -> list[Path]:
+    """
+    Remove this skill from candidate mirror dirs that are not in the layout.
+
+    Only removes what taken owns: symlinks to the main copy, or copies that still match
+    the last-written hash. Anything edited or foreign is left alone. Returns removed paths.
+    """
+    main = main_skill_dir(project_root, layout, name)
+    removed: list[Path] = []
+    for d in candidate_dirs:
+        if d in layout.mirror_dirs:
+            continue
+        path = project_root / d / name
+        if path == main:
+            continue
+        is_ours = is_managed_link(path, main) or (
+            baseline_hash is not None
+            and path.is_dir()
+            and not path.is_symlink()
+            and compute_skill_hash(path) == baseline_hash
+        )
+        if is_ours:
+            remove_path(path)
+            removed.append(path)
+    return removed
 
 
 def real_copies(project_root: Path, layout: SkillLayout, name: str) -> list[Path]:

{taken_cli-0.2.0 → taken_cli-0.2.2}/src/taken/core/project.py

@@ -54,13 +54,17 @@ def _serialize_project(config: ProjectConfig) -> dict[str, Any]:
     data: dict[str, Any] = {}
     if config.mirror_mode is not None:
         data["mirror_mode"] = config.mirror_mode.value
-    data["skills"] = {
-        key: {
-            "copied_at": entry.copied_at.isoformat(),
-            "copied_hash": entry.copied_hash,
-        }
-        for key, entry in config.skills.items()
+    data["skills"] = {key: _serialize_skill(entry) for key, entry in config.skills.items()}
+    return data
+
+
+def _serialize_skill(entry: ProjectSkillEntry) -> dict[str, Any]:
+    data: dict[str, Any] = {
+        "copied_at": entry.copied_at.isoformat(),
+        "copied_hash": entry.copied_hash,
     }
+    if entry.mirror_dirs is not None:
+        data["mirror_dirs"] = list(entry.mirror_dirs)
     return data
 
 
@@ -73,6 +77,7 @@ def _deserialize_project(data: dict[str, Any]) -> ProjectConfig:
             key: ProjectSkillEntry(
                 copied_at=datetime.fromisoformat(entry["copied_at"]),
                 copied_hash=entry.get("copied_hash", ""),
+                mirror_dirs=list(entry["mirror_dirs"]) if entry.get("mirror_dirs") is not None else None,
             )
             for key, entry in raw_skills.items()
         },
@@ -138,3 +143,10 @@ def resolve_layout(config: TakenConfig, project_config: ProjectConfig) -> SkillL
         mirror_dirs=tuple(config.skills.mirror_dirs),
         mirror_mode=project_config.mirror_mode or config.skills.mirror_mode,
     )
+
+
+def skill_layout(layout: SkillLayout, entry: ProjectSkillEntry | None) -> SkillLayout:
+    """Narrow a project layout to the mirror dirs chosen for one skill (if it has a saved choice)."""
+    if entry is None or entry.mirror_dirs is None:
+        return layout
+    return layout.model_copy(update={"mirror_dirs": tuple(entry.mirror_dirs)})

{taken_cli-0.2.0 → taken_cli-0.2.2}/src/taken/main.py

@@ -1,3 +1,5 @@
+from importlib.metadata import version as package_version
+
 import typer
 
 from taken.commands.add import add
@@ -5,10 +7,12 @@ from taken.commands.git import git
 from taken.commands.init import init
 from taken.commands.install import install
 from taken.commands.list import list as list_cmd
+from taken.commands.mirrors import mirrors_app
 from taken.commands.remove import remove
 from taken.commands.save import save
 from taken.commands.update import update
 from taken.commands.use import use
+from taken.utils.console import console
 
 app = typer.Typer(
     name="taken",
@@ -17,6 +21,27 @@ app = typer.Typer(
     rich_markup_mode="rich",
 )
 
+
+def _version_callback(value: bool) -> None:
+    if value:
+        console.print(f"taken {package_version('taken-cli')}")
+        raise typer.Exit()
+
+
+@app.callback()
+def _root(
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-V",
+        help="Show the installed taken version and exit.",
+        callback=_version_callback,
+        is_eager=True,
+    ),
+) -> None:
+    """A very particular set of skills, managed."""
+
+
 app.command("init")(init)
 app.command("add")(add)
 app.command("install")(install)
@@ -25,6 +50,7 @@ app.command("use")(use)
 app.command("save")(save)
 app.command("update")(update)
 app.command("remove")(remove)
+app.add_typer(mirrors_app, name="mirrors")
 app.command("git", context_settings={"allow_extra_args": True, "ignore_unknown_options": True})(git)
 
 

{taken_cli-0.2.0 → taken_cli-0.2.2}/src/taken/models/project.py

@@ -8,6 +8,10 @@ from taken.models.config import MirrorMode
 class ProjectSkillEntry(BaseModel):
     copied_at: datetime
     copied_hash: str
+    mirror_dirs: list[str] | None = Field(
+        default=None,
+        description="Mirror dirs chosen for this skill at `taken use`. None means the global mirror_dirs.",
+    )
 
 
 class ProjectConfig(BaseModel):

taken_cli-0.2.0/src/taken/commands/use.py

@@ -1,198 +0,0 @@
-import shutil
-from datetime import datetime
-from pathlib import Path
-
-import typer
-from InquirerPy import inquirer
-from InquirerPy.enum import (
-    INQUIRERPY_EMPTY_CIRCLE_SEQUENCE,
-    INQUIRERPY_FILL_CIRCLE_SEQUENCE,
-)
-from rich.panel import Panel
-from rich.prompt import Confirm
-
-from taken.core import paths
-from taken.core.config import is_config_exists, read_config
-from taken.core.hashing import compute_skill_hash
-from taken.core.mirror import edited_copies, main_skill_dir, remove_path, sync_mirrors, untracked_paths
-from taken.core.project import read_project_config, resolve_layout, write_project_config
-from taken.core.registry import read_registry
-from taken.models.config import MirrorMode
-from taken.models.project import ProjectConfig, ProjectSkillEntry, SkillLayout
-from taken.models.registry import Registry, RegistryEntry
-from taken.utils.console import console, err_console
-
-
-def _resolve_selected(
-    namespace_skill: str | None,
-    registry: Registry,
-) -> list[RegistryEntry]:
-    """Return the list of skills the user chose; raises typer.Exit on invalid input."""
-    if namespace_skill is not None:
-        entry = registry.get(namespace_skill)
-        if entry is None:
-            err_console.print(
-                Panel(
-                    f"[bold]{namespace_skill}[/bold] not found in registry.\n"
-                    "Run [bold]taken list[/bold] to see available skills.",
-                    title="[red]Skill Not Found[/red]",
-                    border_style="red",
-                )
-            )
-            raise typer.Exit(code=1)
-        return [entry]
-
-    choices = [
-        {"name": f"{e.full_name}  [{e.source.value}]", "value": e.full_name}
-        for e in sorted(registry.skills.values(), key=lambda e: e.full_name)
-    ]
-    selected_names: list[str] = inquirer.fuzzy(  # type: ignore[attr-defined]
-        message="Search skills:",
-        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()
-
-    if not selected_names:
-        raise typer.Exit(code=0)
-
-    return [e for name in selected_names if (e := registry.get(name)) is not None]
-
-
-def use(
-    namespace_skill: str | None = typer.Argument(
-        None,
-        help="Skill to copy into project, e.g. pradyothsp/hello-world. Omit for interactive picker.",
-    ),
-    mode: MirrorMode | None = typer.Option(  # noqa: B008
-        None,
-        "--mode",
-        help="How to mirror into extra dirs like .claude/skills (symlink or copy). Remembered for this project.",
-        case_sensitive=False,
-    ),
-) -> None:
-    """Copy skill(s) from ~/.taken/ into the current project's skills dir and mirror them to agent dirs."""
-    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:
-        err_console.print(
-            Panel(
-                "No skills in your registry yet. Run [bold]taken add[/bold] to create one.",
-                title="[red]Registry Empty[/red]",
-                border_style="red",
-            )
-        )
-        raise typer.Exit(code=1)
-
-    selected = _resolve_selected(namespace_skill, registry)
-
-    project_root = Path.cwd()
-    project_config = read_project_config(project_root)
-    if mode is not None:
-        project_config.mirror_mode = mode
-    layout = resolve_layout(read_config(paths.TAKEN_HOME), project_config)
-
-    now = datetime.now()
-    copied: list[str] = []
-    skipped: list[str] = []
-
-    for entry in selected:
-        if not _confirm_overwrite(entry, project_root, layout, project_config):
-            skipped.append(entry.full_name)
-            continue
-
-        fell_back = _copy_skill(entry, project_root, layout, project_config, now)
-        copied.append(_describe_copy(entry, layout))
-        for dst in fell_back:
-            err_console.print(
-                f"[yellow]⚠[/yellow]  Could not symlink [bold]{dst.relative_to(project_root)}[/bold] — copied instead."
-            )
-
-    if not copied and not skipped:
-        return
-
-    write_project_config(project_config, project_root)
-
-    if copied:
-        lines = "\n".join(copied) + "\n\n[dim]Tracked in ~/.taken/projects.yaml[/dim]"
-        console.print(
-            Panel(
-                lines,
-                title="[green]Skills Added[/green]",
-                border_style="green",
-                padding=(1, 2),
-            )
-        )
-    if skipped:
-        console.print(f"[dim]Skipped: {', '.join(skipped)}[/dim]")
-
-
-def _confirm_overwrite(
-    entry: RegistryEntry,
-    project_root: Path,
-    layout: SkillLayout,
-    project_config: ProjectConfig,
-) -> bool:
-    """Ask before clobbering local edits or folders taken did not create. Returns True to proceed."""
-    existing = project_config.skills.get(entry.full_name)
-
-    if existing is not None:
-        if edited_copies(project_root, layout, entry.name, existing.copied_hash):
-            console.print(f"\n[yellow]⚠[/yellow]  [bold]{entry.name}[/bold] has local changes in your project.")
-            return Confirm.ask(f"  Overwrite [bold]{entry.name}[/bold]?", default=False)
-        return True
-
-    foreign = untracked_paths(project_root, layout, entry.name)
-    if foreign:
-        listed = ", ".join(str(p.relative_to(project_root)) for p in foreign)
-        console.print(f"\n[yellow]⚠[/yellow]  [bold]{listed}[/bold] already exists and was not created by taken.")
-        return Confirm.ask(f"  Overwrite with [bold]{entry.full_name}[/bold]?", default=False)
-
-    return True
-
-
-def _describe_copy(entry: RegistryEntry, layout: SkillLayout) -> str:
-    line = f"[green]✓[/green] [bold]{entry.full_name}[/bold] → {layout.main_dir}/{entry.name}/"
-    if layout.mirror_dirs:
-        verb = "linked" if layout.mirror_mode == MirrorMode.SYMLINK else "copied"
-        targets = ", ".join(f"{d}/{entry.name}/" for d in layout.mirror_dirs)
-        line += f"\n  [dim]{verb} to {targets}[/dim]"
-    return line
-
-
-def _copy_skill(
-    entry: RegistryEntry,
-    project_root: Path,
-    layout: SkillLayout,
-    project_config: ProjectConfig,
-    now: datetime,
-) -> list[Path]:
-    """Copy registry skill into the main dir, then mirror it. Returns mirrors that fell back to copy."""
-    src = paths.TAKEN_HOME / "skills" / entry.namespace / entry.name
-    dst = main_skill_dir(project_root, layout, entry.name)
-
-    dst.parent.mkdir(parents=True, exist_ok=True)
-    remove_path(dst)
-    shutil.copytree(src, dst)
-    fell_back = sync_mirrors(project_root, layout, entry.name)
-
-    project_config.skills[entry.full_name] = ProjectSkillEntry(
-        copied_at=now,
-        copied_hash=compute_skill_hash(dst),
-    )
-    return fell_back