Agent Skills for Developer Tooling.

import os
TEAMS = ["frontend", "backend", "data", "shared"]
for t in TEAMS:
    os.makedirs(f".claude/skills/{t}", exist_ok=True)
    with open(f".claude/skills/{t}/.gitkeep", "w") as f:
        pass
print("namespace-by-team layout ready; commit and start authoring.")

# .claude/skills/frontend/refactor-component.md
SKILL_TEMPLATE = """---
name: frontend/refactor-component
version: 1.2.3
description: |
  Rename a React component and update every import + usage in the repo.
  Runs in context: fork so the working tree is untouched until you approve.
when_to_use: |
  When the user asks to rename a React component or move it between files.
parameters:
  old_name:
    type: string
    description: Current PascalCase component name (e.g. UserCard)
    required: true
  new_name:
    type: string
    description: Target PascalCase component name (e.g. UserProfile)
    required: true
  directory:
    type: string
    default: src/
    description: Directory to scope the search (default: src/)
allowed-tools:
  - Read
  - Grep
  - Glob
  - Edit
context_mode: fork
---

You are renaming a React component across this repository.

Steps:
1. Glob {directory}/**/*.{tsx,ts,jsx,js} to find candidate files.
2. Grep for {old_name} across the matched files; collect file + line.
3. For each match, Read the file and decide whether the occurrence is the
   component (the import/export/JSX-tag) or a coincidental string.
4. Edit each file. Update the filename if the file is currently {old_name}.tsx.
5. Return a structured summary: files touched, occurrences changed.
"""

from anthropic import Anthropic
import yaml
client = Anthropic()

def parse_skill(path: str) -> dict:
    text = open(path).read()
    if not text.startswith("---"):
        raise ValueError(f"{path}: missing frontmatter")
    _, fm, body = text.split("---", 2)
    return {"frontmatter": yaml.safe_load(fm), "body": body.strip()}

def invoke_skill_in_fork(skill_path: str, params: dict, user_message: str) -> dict:
    """Spawn a child session for the Skill. Parent state untouched."""
    skill = parse_skill(skill_path)
    fm = skill["frontmatter"]

    rendered_body = skill["body"]
    for k, v in params.items():
        rendered_body = rendered_body.replace("{" + k + "}", str(v))

    child_response = client.messages.create(
        model="claude-sonnet-4.5",
        max_tokens=4096,
        system=rendered_body,
        tools=load_tools_from_whitelist(fm["allowed-tools"]),
        messages=[{"role": "user", "content": user_message}],
    )
    return {
        "skill_name": fm["name"],
        "skill_version": fm["version"],
        "child_stop_reason": child_response.stop_reason,
        "child_content": child_response.content,
    }

from anthropic.types import Tool

ALL_TOOLS: dict[str, Tool] = {
    "Read":  {"name": "Read",  "description": "...", "input_schema": {}},
    "Edit":  {"name": "Edit",  "description": "...", "input_schema": {}},
    "Bash":  {"name": "Bash",  "description": "...", "input_schema": {}},
    "Grep":  {"name": "Grep",  "description": "...", "input_schema": {}},
    "Glob":  {"name": "Glob",  "description": "...", "input_schema": {}},
    "Write": {"name": "Write", "description": "...", "input_schema": {}},
}
KNOWN_TOOLS = set(ALL_TOOLS)

def load_tools_from_whitelist(whitelist: list[str]) -> list[Tool]:
    unknown = set(whitelist) - KNOWN_TOOLS
    if unknown:
        raise ValueError(f"Skill frontmatter references unknown tools: {unknown}")
    return [ALL_TOOLS[name] for name in whitelist]

# A refactor Skill whitelist
TOOLS_FOR_REFACTOR = load_tools_from_whitelist(["Read", "Grep", "Glob", "Edit"])
# A test-gen Skill whitelist (no Edit, no Bash)
TOOLS_FOR_TESTGEN = load_tools_from_whitelist(["Read", "Grep", "Glob"])

import jsonschema

def validate_params(skill_fm: dict, params: dict) -> None:
    schema = {"type": "object", "properties": {}, "required": []}
    for name, spec in skill_fm.get("parameters", {}).items():
        schema["properties"][name] = {"type": spec["type"]}
        if spec.get("required"):
            schema["required"].append(name)
    try:
        jsonschema.validate(instance=params, schema=schema)
    except jsonschema.ValidationError as e:
        raise ValueError(f"invalid params for skill {skill_fm['name']}: {e.message}")

# CLI: claude skills invoke <skill> --param key=value
def parse_cli_params(argv: list[str]) -> dict:
    params = {}
    i = 0
    while i < len(argv):
        if argv[i] == "--param" and i + 1 < len(argv):
            k, _, v = argv[i + 1].partition("=")
            params[k] = v
            i += 2
        else:
            i += 1
    return params

# VSCode extension (TypeScript) - pseudo-Python summary of what it does
def vscode_command_refactor_component(editor_state):
    """The user invoked the 'Claude: Refactor This Component' palette item."""
    selection = editor_state.get_selected_text()
    workspace_root = editor_state.get_workspace_root()

    cli_args = [
        "claude", "skills", "invoke", "frontend/refactor-component",
        "--param", f"old_name={selection}",
        "--param", "new_name=AskUserViaInputBox",
        "--param", f"directory={workspace_root}/src/",
    ]
    proc = run_subprocess(cli_args, cwd=workspace_root)
    stream_to_editor_panel(proc.stdout)

import glob, yaml
from pathlib import Path

def list_skills(roots: list[str]) -> list[dict]:
    out = []
    for root in roots:
        for path in glob.glob(f"{root}/**/*.md", recursive=True):
            try:
                text = Path(path).read_text()
                _, fm, _ = text.split("---", 2)
                meta = yaml.safe_load(fm)
                out.append({
                    "name": meta["name"],
                    "version": meta["version"],
                    "description": meta["description"].strip().split("\n")[0],
                    "parameters": list(meta.get("parameters", {}).keys()),
                    "path": path,
                })
            except (ValueError, KeyError):
                pass
    return sorted(out, key=lambda s: s["name"])

def cmd_skills_list(team: str | None = None):
    skills = list_skills([".claude/skills", str(Path.home() / ".claude/skills")])
    if team:
        skills = [s for s in skills if s["name"].startswith(f"{team}/")]
    for s in skills:
        print(f"{s['name']}@{s['version']:<8}  {s['description']}")

import subprocess, semver

def tag_skill_release(skill_path: str, new_version: str):
    semver.VersionInfo.parse(new_version)
    skill_name = parse_skill(skill_path)["frontmatter"]["name"]
    tag = f"{skill_name.replace('/', '-')}@{new_version}"
    update_frontmatter_version(skill_path, new_version)
    subprocess.run(["git", "add", skill_path], check=True)
    subprocess.run(["git", "commit", "-m", f"chore(skill): bump {skill_name} to {new_version}"], check=True)
    subprocess.run(["git", "tag", "-a", tag, "-m", f"{skill_name} {new_version}"], check=True)
    print(f"tagged {tag}")

def resolve_caller_pin(skill_name: str, pin: str) -> str:
    if pin.endswith(".x"):
        major = int(pin.split(".")[0])
        tags = subprocess.check_output(
            ["git", "tag", "-l", f"{skill_name.replace('/', '-')}@{major}.*"],
            text=True,
        ).strip().split("\n")
        versions = [t.split("@", 1)[1] for t in tags if t]
        return max(versions, key=lambda v: semver.VersionInfo.parse(v))
    return pin