skillchef 0.2.0__py3-none-any.whl

skillchef/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

skillchef/cli.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import click
+
+from skillchef.commands import (
+    cook_cmd,
+    flavor_cmd,
+    init_cmd,
+    list_cmd as list_command,
+    remove_cmd,
+    sync_cmd,
+)
+
+
+@click.group()
+def main() -> None:
+    """skillchef — cook, flavor & sync your agent skills."""
+    pass
+
+
+@main.command()
+def init() -> None:
+    """First-time setup: platforms, editor, model."""
+    init_cmd.run()
+
+
+@main.command()
+@click.argument("source")
+def cook(source: str) -> None:
+    """Import a skill from a remote source or local path."""
+    cook_cmd.run(source)
+
+
+@main.command()
+@click.argument("skill_name", required=False)
+@click.option("--no-ai", is_flag=True, help="Disable automatic AI merge proposals.")
+def sync(skill_name: str | None, no_ai: bool) -> None:
+    """Check remotes for updates and merge."""
+    sync_cmd.run(skill_name, no_ai)
+
+
+@main.command()
+@click.argument("skill_name", required=False)
+def flavor(skill_name: str | None) -> None:
+    """Add or edit a local flavor for a skill."""
+    flavor_cmd.run(skill_name)
+
+
+@main.command(name="list")
+def list_cmd() -> None:
+    """List all managed skills."""
+    list_command.run()
+
+
+@main.command()
+@click.argument("skill_name")
+def remove(skill_name: str) -> None:
+    """Remove a managed skill."""
+    remove_cmd.run(skill_name)
+
+
+if __name__ == "__main__":
+    main()

skillchef/commands/__init__.py

@@ -0,0 +1 @@
+"""Namespaced command implementations for the Skillchef CLI."""

skillchef/commands/common.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from skillchef import config, ui
+
+
+def ensure_config() -> dict[str, Any]:
+    cfg = config.load()
+    if not cfg.get("platforms"):
+        ui.warn("No config found. Run [bold]skillchef init[/bold] first.")
+        raise SystemExit(1)
+    return cfg
+
+
+def open_editor(path: Path) -> None:
+    cfg = config.load()
+    ed = config.editor(cfg)
+    subprocess.call([ed, str(path)])
+
+
+def cleanup_fetched(fetched_dir: Path) -> None:
+    root = fetched_dir.parent if fetched_dir.name == "skill" else fetched_dir
+    shutil.rmtree(root, ignore_errors=True)

skillchef/commands/cook_cmd.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from skillchef import config, merge, remote, store, ui
+
+from .common import cleanup_fetched, ensure_config
+
+
+def run(source: str) -> None:
+    ui.banner()
+    cfg = ensure_config()
+
+    ui.info(f"Fetching from {source}...")
+    try:
+        fetched_dir, remote_type = remote.fetch(source)
+    except Exception as e:
+        ui.error(f"Failed to fetch: {e}")
+        raise SystemExit(1)
+
+    skill_md = fetched_dir / "SKILL.md"
+    default_name = fetched_dir.name
+    if skill_md.exists():
+        front, _ = merge.split_frontmatter(skill_md.read_text())
+        if "name:" in front:
+            for line in front.splitlines():
+                if line.strip().startswith("name:"):
+                    default_name = line.split(":", 1)[1].strip().strip('"').strip("'")
+                    break
+
+    name = ui.ask("Skill name", default=default_name)
+    platforms = ui.multi_choose("Target platforms", cfg.get("platforms", list(config.PLATFORMS.keys())))
+
+    store.cook(name, fetched_dir, source, remote_type, platforms)
+    cleanup_fetched(fetched_dir)
+
+    ui.success(f"Cooked [bold]{name}[/bold]!")
+    for p in platforms:
+        ui.info(f"Symlinked → {config.platform_skill_dir(p) / name}")

skillchef/commands/flavor_cmd.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from skillchef import merge, store, ui
+
+from .common import ensure_config, open_editor
+
+
+def run(skill_name: str | None) -> None:
+    ui.banner()
+    ensure_config()
+
+    skills = store.list_skills()
+    if not skills:
+        ui.info("No skills cooked yet.")
+        return
+
+    if not skill_name:
+        names = [s["name"] for s in skills]
+        skill_name = ui.choose("Which skill?", names)
+
+    fp = store.flavor_path(skill_name)
+    if not fp.exists():
+        fp.write_text("# Add your local flavor below\n\n")
+
+    old_live = store.live_skill_text(skill_name)
+    open_editor(fp)
+    store.rebuild_live(skill_name)
+    new_live = store.live_skill_text(skill_name)
+
+    diff_lines = merge.diff_texts(old_live, new_live, "before", "after")
+    ui.show_diff(diff_lines)
+    ui.success(f"Flavor saved for [bold]{skill_name}[/bold]")

skillchef/commands/init_cmd.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import os
+
+from skillchef import config, ui
+from skillchef.llm import detect_keys
+
+
+def run() -> None:
+    ui.banner()
+    ui.console.print()
+
+    ui.info("Scanning for agent platforms...\n")
+    ui.show_platforms(config.PLATFORMS)
+    ui.console.print()
+
+    detected = detect_keys()
+    ui.show_detected_keys(detected)
+    ui.console.print()
+
+    platforms = ui.multi_choose(
+        "Which platforms do you use?",
+        list(config.PLATFORMS.keys()),
+    )
+
+    editor = ui.ask("Preferred editor", default=os.environ.get("EDITOR", "vim"))
+
+    default_model = "anthropic/claude-sonnet-4-20250514"
+    selected_key_env = ""
+    if detected:
+        if len(detected) == 1:
+            selected_key_env, provider = detected[0]
+        else:
+            label_to_env = {f"{provider} ({env_var})": env_var for env_var, provider in detected}
+            key_choices = list(label_to_env.keys())
+            selected_label = ui.choose("Multiple LLM keys found. Which key should AI merge use?", key_choices)
+            selected_key_env = label_to_env[selected_label]
+            provider = next(p for env_var, p in detected if env_var == selected_key_env)
+        ui.info(f"AI merge will use [bold]{selected_key_env}[/bold] ({provider})")
+    model = ui.ask("AI model for semantic merge", default=default_model)
+
+    cfg = {"platforms": platforms, "editor": editor, "model": model, "llm_api_key_env": selected_key_env}
+    config.save(cfg)
+
+    ui.console.print()
+    ui.show_config_summary(cfg)
+    ui.console.print()
+    ui.success(f"Config saved to [bold]{config.CONFIG_PATH}[/bold]")

skillchef/commands/list_cmd.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from skillchef import store, ui
+
+
+def run() -> None:
+    ui.banner()
+    ui.skill_table(store.list_skills(), has_flavor_fn=store.has_flavor)

skillchef/commands/remove_cmd.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from skillchef import store, ui
+
+
+def run(skill_name: str) -> None:
+    ui.banner()
+    try:
+        store.load_meta(skill_name)
+    except FileNotFoundError:
+        ui.error(f"Skill '{skill_name}' not found.")
+        raise SystemExit(1)
+
+    if ui.confirm(f"Remove [bold]{skill_name}[/bold]?", default=False):
+        store.remove(skill_name)
+        ui.success(f"Removed {skill_name}")

skillchef/commands/sync_cmd.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from concurrent.futures import Future, ThreadPoolExecutor
+from typing import Any
+
+from skillchef import config, merge, remote, store, ui
+from skillchef.llm import selected_key, semantic_merge
+
+from .common import cleanup_fetched, ensure_config, open_editor
+
+
+def run(skill_name: str | None, no_ai: bool) -> None:
+    ui.banner()
+    ensure_config()
+
+    cfg = config.load()
+    key = selected_key(cfg.get("llm_api_key_env", ""))
+    ai_available = key is not None and not no_ai
+    if ai_available and key:
+        ui.info(f"Using [bold]{key[0]}[/bold] ({key[1]}) for semantic merge")
+
+    skills = store.list_skills()
+    if not skills:
+        ui.info("No skills to sync.")
+        return
+
+    if skill_name:
+        skills = [s for s in skills if s["name"] == skill_name]
+        if not skills:
+            ui.error(f"Skill '{skill_name}' not found.")
+            raise SystemExit(1)
+
+    for meta in skills:
+        _sync_one(meta, ai_available=ai_available)
+
+
+def _sync_one(meta: dict[str, Any], ai_available: bool = False) -> None:
+    name = meta["name"]
+    ui.info(f"Syncing [bold]{name}[/bold]...")
+
+    try:
+        fetched_dir, _ = remote.fetch(meta["remote_url"])
+    except Exception as e:
+        ui.warn(f"  Could not fetch {name}: {e}")
+        return
+
+    new_hash = store.hash_dir(fetched_dir)
+    if new_hash == meta.get("base_sha256"):
+        ui.success(f"  {name}: up to date")
+        cleanup_fetched(fetched_dir)
+        return
+
+    old_base = store.base_skill_text(name)
+    new_remote = (fetched_dir / "SKILL.md").read_text() if (fetched_dir / "SKILL.md").exists() else ""
+    diff_lines = merge.diff_texts(old_base, new_remote, "base (current)", "remote (new)")
+
+    ai_future: Future[str] | None = None
+    flavor_text = ""
+    if store.has_flavor(name) and ai_available:
+        flavor_text = store.flavor_path(name).read_text()
+        executor = ThreadPoolExecutor(max_workers=1)
+        ai_future = executor.submit(semantic_merge, old_base, new_remote, flavor_text)
+
+    ui.show_diff(diff_lines)
+
+    if not store.has_flavor(name):
+        if ui.confirm("Accept update?"):
+            store.update_base(name, fetched_dir)
+            store.rebuild_live(name)
+            ui.success(f"  {name}: updated")
+        else:
+            ui.info(f"  {name}: skipped")
+    else:
+        if not flavor_text:
+            flavor_text = store.flavor_path(name).read_text()
+
+        ai_result = _resolve_ai_future(ai_future)
+        choices = ["accept + re-apply flavor", "keep current", "manual edit"]
+        if ai_result:
+            choices.insert(0, "accept ai merge")
+            ui.info("AI proposed a semantic merge:")
+            ai_diff = merge.diff_texts(store.live_skill_text(name), ai_result, "current", "ai proposed")
+            ui.show_diff(ai_diff)
+
+        action = ui.choose("How to handle?", choices)
+
+        if action == "accept ai merge" and ai_result:
+            store.update_base(name, fetched_dir)
+            live_md = store.skill_dir(name) / "live" / "SKILL.md"
+            live_md.write_text(ai_result)
+            ui.success(f"  {name}: AI merged")
+        elif action == "accept + re-apply flavor":
+            store.update_base(name, fetched_dir)
+            store.rebuild_live(name)
+            ui.success(f"  {name}: rebased with flavor")
+        elif action == "keep current":
+            ui.info(f"  {name}: skipped")
+        elif action == "manual edit":
+            store.update_base(name, fetched_dir)
+            store.rebuild_live(name)
+            open_editor(store.skill_dir(name) / "live" / "SKILL.md")
+            ui.success(f"  {name}: manually merged")
+
+    cleanup_fetched(fetched_dir)
+
+
+def _resolve_ai_future(future: Future[str] | None) -> str | None:
+    if future is None:
+        return None
+    try:
+        with ui.spinner("Waiting for AI merge proposal..."):
+            return future.result(timeout=60)
+    except Exception as e:
+        ui.warn(f"  AI merge failed: {e}")
+        return None

skillchef/config.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import os
+import tomllib
+from pathlib import Path
+from typing import Any
+
+import tomli_w
+
+SKILLCHEF_HOME = Path.home() / ".skillchef"
+CONFIG_PATH = SKILLCHEF_HOME / "config.toml"
+STORE_DIR = SKILLCHEF_HOME / "store"
+
+PLATFORMS: dict[str, Path] = {
+    "codex": Path.home() / ".codex" / "skills",
+    "cursor": Path.home() / ".cursor" / "skills",
+    "claude-code": Path.home() / ".claude" / "skills",
+}
+
+DEFAULT_CONFIG: dict[str, Any] = {
+    "platforms": [],
+    "editor": "",
+    "model": "anthropic/claude-sonnet-4-20250514",
+    "llm_api_key_env": "",
+}
+
+
+def load() -> dict[str, Any]:
+    if not CONFIG_PATH.exists():
+        return dict(DEFAULT_CONFIG)
+    return tomllib.loads(CONFIG_PATH.read_text())
+
+
+def save(cfg: dict[str, Any]) -> None:
+    SKILLCHEF_HOME.mkdir(parents=True, exist_ok=True)
+    CONFIG_PATH.write_bytes(tomli_w.dumps(cfg).encode())
+
+
+def editor(cfg: dict[str, Any] | None = None) -> str:
+    cfg = cfg or load()
+    return cfg.get("editor") or os.environ.get("EDITOR", "vim")
+
+
+def platform_skill_dir(platform: str) -> Path:
+    return PLATFORMS[platform]
+
+
+def ensure_store() -> Path:
+    STORE_DIR.mkdir(parents=True, exist_ok=True)
+    return STORE_DIR

skillchef/llm.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import os
+
+from litellm import completion
+
+from skillchef import config
+
+LLM_KEY_MAP = [
+    ("ANTHROPIC_API_KEY", "Anthropic"),
+    ("OPENAI_API_KEY", "OpenAI"),
+    ("GEMINI_API_KEY", "Google Gemini"),
+    ("MISTRAL_API_KEY", "Mistral"),
+    ("COHERE_API_KEY", "Cohere"),
+    ("OLLAMA_API_BASE", "Ollama (local)"),
+]
+
+MERGE_PROMPT = """You are merging an agent skill file. The upstream base has changed.
+The user has a local "flavor" (customization) applied on top of the old base.
+
+Your job: produce a single merged SKILL.md that incorporates BOTH the new upstream
+changes AND the user's local flavor. Preserve the intent of both sides.
+
+Return ONLY the merged file content, no explanation.
+
+=== OLD BASE ===
+{old_base}
+
+=== NEW REMOTE (upstream update) ===
+{new_remote}
+
+=== USER'S LOCAL FLAVOR ===
+{flavor}
+
+=== MERGED RESULT ==="""
+
+
+def detect_keys() -> list[tuple[str, str]]:
+    return [(k, v) for k, v in LLM_KEY_MAP if os.environ.get(k)]
+
+
+def selected_key(preferred_env_var: str | None = None) -> tuple[str, str] | None:
+    keys = detect_keys()
+    if not keys:
+        return None
+    if preferred_env_var:
+        for env_var, provider in keys:
+            if env_var == preferred_env_var:
+                return env_var, provider
+    return keys[0]
+
+
+def has_llm() -> bool:
+    return len(detect_keys()) > 0
+
+
+def semantic_merge(old_base: str, new_remote: str, flavor: str, model: str | None = None) -> str:
+    cfg = config.load()
+    model = model or cfg.get("model", "anthropic/claude-sonnet-4-20250514")
+    configured_env = cfg.get("llm_api_key_env", "")
+    key = selected_key(configured_env)
+
+    completion_kwargs: dict[str, str | int | list[dict[str, str]]] = {}
+    if key:
+        env_var, _provider = key
+        value = os.environ.get(env_var, "")
+        if value:
+            if env_var == "OLLAMA_API_BASE":
+                completion_kwargs["api_base"] = value
+            else:
+                completion_kwargs["api_key"] = value
+
+    prompt = MERGE_PROMPT.format(old_base=old_base, new_remote=new_remote, flavor=flavor)
+    resp = completion(
+        model=model,
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0,
+        **completion_kwargs,
+    )
+    return resp.choices[0].message.content.strip()

skillchef/merge.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import difflib
+import re
+from pathlib import Path
+
+FRONTMATTER_RE = re.compile(r"^---\s*\n(.*?\n)---\s*\n", re.DOTALL)
+FLAVOR_HEADER = "\n\n## Local Flavor\n\n"
+
+
+def split_frontmatter(text: str) -> tuple[str, str]:
+    m = FRONTMATTER_RE.match(text)
+    if m:
+        return text[: m.end()], text[m.end() :]
+    return "", text
+
+
+def merge_skill(live_skill_path: Path, flavor_path: Path) -> None:
+    base_text = live_skill_path.read_text()
+    flavor_text = flavor_path.read_text().strip()
+    if not flavor_text:
+        return
+    front, body = split_frontmatter(base_text)
+    body = body.rstrip()
+    merged = front + body + FLAVOR_HEADER + flavor_text + "\n"
+    live_skill_path.write_text(merged)
+
+
+def diff_texts(old: str, new: str, label_old: str = "old", label_new: str = "new") -> list[str]:
+    return list(difflib.unified_diff(
+        old.splitlines(keepends=True),
+        new.splitlines(keepends=True),
+        fromfile=label_old,
+        tofile=label_new,
+    ))
+
+
+def three_way_summary(old_base: str, new_remote: str, flavor: str) -> str:
+    lines = []
+    base_diff = diff_texts(old_base, new_remote, "base (old)", "remote (new)")
+    if base_diff:
+        lines.append("=== Upstream changes ===")
+        lines.extend(base_diff)
+    if flavor.strip():
+        lines.append("\n=== Your flavor ===")
+        lines.append(flavor)
+    return "".join(lines)

skillchef/remote.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import re
+import shutil
+import tempfile
+from pathlib import Path
+from urllib.parse import urlparse
+
+import httpx
+
+GITHUB_TREE_RE = re.compile(
+    r"github\.com/(?P<owner>[^/]+)/(?P<repo>[^/]+)/tree/(?P<ref>[^/]+)/(?P<path>.+)"
+)
+GITHUB_BLOB_RE = re.compile(
+    r"github\.com/(?P<owner>[^/]+)/(?P<repo>[^/]+)/blob/(?P<ref>[^/]+)/(?P<path>.+)"
+)
+
+
+def classify(source: str) -> str:
+    if Path(source).exists():
+        return "local"
+    parsed = urlparse(source)
+    if "github.com" in (parsed.hostname or ""):
+        return "github"
+    if parsed.scheme in ("http", "https"):
+        return "http"
+    raise ValueError(f"Cannot classify source: {source}")
+
+
+def fetch(source: str) -> tuple[Path, str]:
+    """Fetch skill content into a temp directory.
+    Returns (temp_dir_path, remote_type).
+    Caller is responsible for cleanup.
+    """
+    kind = classify(source)
+    if kind == "local":
+        return _fetch_local(source), kind
+    if kind == "github":
+        return _fetch_github(source), kind
+    return _fetch_http(source), kind
+
+
+def _fetch_local(source: str) -> Path:
+    src = Path(source).resolve()
+    tmp = Path(tempfile.mkdtemp(prefix="skillchef-"))
+    if src.is_dir():
+        shutil.copytree(src, tmp / "skill", dirs_exist_ok=True)
+        return tmp / "skill"
+    tmp_skill = tmp / "skill"
+    tmp_skill.mkdir()
+    shutil.copy2(src, tmp_skill / src.name)
+    return tmp_skill
+
+
+def _fetch_github(source: str) -> Path:
+    m = GITHUB_TREE_RE.search(source) or GITHUB_BLOB_RE.search(source)
+    if not m:
+        raise ValueError(f"Cannot parse GitHub URL: {source}")
+    owner, repo, ref, path = m.group("owner"), m.group("repo"), m.group("ref"), m.group("path")
+    return _fetch_github_dir(owner, repo, ref, path)
+
+
+def _fetch_github_dir(owner: str, repo: str, ref: str, path: str) -> Path:
+    api_url = f"https://api.github.com/repos/{owner}/{repo}/contents/{path}?ref={ref}"
+    tmp = Path(tempfile.mkdtemp(prefix="skillchef-"))
+    skill_dir = tmp / "skill"
+    skill_dir.mkdir()
+    _download_github_path(api_url, skill_dir)
+    return skill_dir
+
+
+def _download_github_path(api_url: str, dest: Path) -> None:
+    with httpx.Client(follow_redirects=True, timeout=30) as client:
+        resp = client.get(api_url, headers={"Accept": "application/vnd.github.v3+json"})
+        resp.raise_for_status()
+        data = resp.json()
+
+    if isinstance(data, dict) and data.get("type") == "file":
+        _download_raw(data["download_url"], dest / data["name"])
+        return
+
+    if isinstance(data, list):
+        for item in data:
+            if item["type"] == "file":
+                _download_raw(item["download_url"], dest / item["name"])
+            elif item["type"] == "dir":
+                sub = dest / item["name"]
+                sub.mkdir(exist_ok=True)
+                _download_github_path(item["url"], sub)
+
+
+def _download_raw(url: str, dest: Path) -> None:
+    with httpx.Client(follow_redirects=True, timeout=30) as client:
+        resp = client.get(url)
+        resp.raise_for_status()
+        dest.write_bytes(resp.content)
+
+
+def _fetch_http(source: str) -> Path:
+    tmp = Path(tempfile.mkdtemp(prefix="skillchef-"))
+    skill_dir = tmp / "skill"
+    skill_dir.mkdir()
+    parsed = urlparse(source)
+    filename = Path(parsed.path).name or "SKILL.md"
+    _download_raw(source, skill_dir / filename)
+    return skill_dir

skillchef/store.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import hashlib
+import shutil
+import tomllib
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import tomli_w
+
+from skillchef import config
+from skillchef.merge import merge_skill
+
+
+def skill_dir(name: str) -> Path:
+    return config.ensure_store() / name
+
+
+def list_skills() -> list[dict[str, Any]]:
+    store = config.STORE_DIR
+    if not store.exists():
+        return []
+    skills = []
+    for d in sorted(store.iterdir()):
+        meta_path = d / "meta.toml"
+        if d.is_dir() and meta_path.exists():
+            skills.append(load_meta(d.name))
+    return skills
+
+
+def load_meta(name: str) -> dict[str, Any]:
+    meta_path = skill_dir(name) / "meta.toml"
+    return tomllib.loads(meta_path.read_text())
+
+
+def save_meta(name: str, meta: dict[str, Any]) -> None:
+    meta_path = skill_dir(name) / "meta.toml"
+    meta_path.write_bytes(tomli_w.dumps(meta).encode())
+
+
+def cook(name: str, fetched_dir: Path, remote_url: str, remote_type: str, platforms: list[str]) -> Path:
+    """Install a fetched skill into the store."""
+    sd = skill_dir(name)
+    base_dir = sd / "base"
+    live_dir = sd / "live"
+
+    if sd.exists():
+        shutil.rmtree(sd)
+    sd.mkdir(parents=True)
+
+    shutil.copytree(fetched_dir, base_dir)
+    shutil.copytree(base_dir, live_dir)
+
+    meta = {
+        "name": name,
+        "remote_url": remote_url,
+        "remote_type": remote_type,
+        "base_sha256": hash_dir(base_dir),
+        "last_sync": datetime.now(timezone.utc).isoformat(),
+        "platforms": platforms,
+    }
+    save_meta(name, meta)
+    _create_symlinks(name, platforms)
+    return sd
+
+
+def remove(name: str) -> None:
+    meta = load_meta(name)
+    _remove_symlinks(name, meta.get("platforms", []))
+    shutil.rmtree(skill_dir(name))
+
+
+def update_base(name: str, fetched_dir: Path) -> None:
+    sd = skill_dir(name)
+    base_dir = sd / "base"
+    if base_dir.exists():
+        shutil.rmtree(base_dir)
+    shutil.copytree(fetched_dir, base_dir)
+    meta = load_meta(name)
+    meta["base_sha256"] = hash_dir(base_dir)
+    meta["last_sync"] = datetime.now(timezone.utc).isoformat()
+    save_meta(name, meta)
+
+
+def rebuild_live(name: str) -> None:
+    sd = skill_dir(name)
+    live_dir = sd / "live"
+    if live_dir.exists():
+        shutil.rmtree(live_dir)
+    shutil.copytree(sd / "base", live_dir)
+    flavor_path = sd / "flavor.md"
+    if flavor_path.exists():
+        merge_skill(live_dir / "SKILL.md", flavor_path)
+
+
+def has_flavor(name: str) -> bool:
+    return (skill_dir(name) / "flavor.md").exists()
+
+
+def flavor_path(name: str) -> Path:
+    return skill_dir(name) / "flavor.md"
+
+
+def base_skill_text(name: str) -> str:
+    return (skill_dir(name) / "base" / "SKILL.md").read_text()
+
+
+def live_skill_text(name: str) -> str:
+    return (skill_dir(name) / "live" / "SKILL.md").read_text()
+
+
+def hash_dir(path: Path) -> str:
+    h = hashlib.sha256()
+    for f in sorted(path.rglob("*")):
+        if f.is_file():
+            h.update(f.relative_to(path).as_posix().encode())
+            h.update(f.read_bytes())
+    return h.hexdigest()
+
+
+def _create_symlinks(name: str, platforms: list[str]) -> None:
+    live_dir = skill_dir(name) / "live"
+    for p in platforms:
+        target = config.platform_skill_dir(p) / name
+        target.parent.mkdir(parents=True, exist_ok=True)
+        if target.exists() or target.is_symlink():
+            target.unlink() if target.is_symlink() else shutil.rmtree(target)
+        target.symlink_to(live_dir)
+
+
+def _remove_symlinks(name: str, platforms: list[str]) -> None:
+    for p in platforms:
+        target = config.platform_skill_dir(p) / name
+        if target.is_symlink():
+            target.unlink()
+        elif target.exists():
+            shutil.rmtree(target)

skillchef/ui.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import sys
+from typing import Any, Callable
+
+from questionary import Choice
+import questionary
+from rich.console import Console
+from rich.columns import Columns
+from rich.prompt import Prompt, Confirm
+from rich.syntax import Syntax
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+
+console = Console()
+
+
+def banner() -> None:
+    console.print(Panel.fit("[bold]skillchef[/bold]  ·  cook, flavor & sync your skills", border_style="dim"))
+
+
+def success(msg: str) -> None:
+    console.print(f"[green]✓[/green] {msg}")
+
+
+def info(msg: str) -> None:
+    console.print(f"[dim]→[/dim] {msg}")
+
+
+def warn(msg: str) -> None:
+    console.print(f"[yellow]![/yellow] {msg}")
+
+
+def error(msg: str) -> None:
+    console.print(f"[red]✗[/red] {msg}")
+
+
+def ask(prompt: str, default: str = "") -> str:
+    return Prompt.ask(f"  {prompt}", default=default, console=console)
+
+
+def confirm(prompt: str, default: bool = True) -> bool:
+    return Confirm.ask(f"  {prompt}", default=default, console=console)
+
+
+def choose(prompt: str, choices: list[str]) -> str:
+    if _can_use_interactive_selector():
+        selected = questionary.select(
+            f"  {prompt}",
+            choices=choices,
+            qmark="",
+        ).ask()
+        if selected:
+            return selected
+
+    for i, c in enumerate(choices, 1):
+        console.print(f"  [dim]{i}.[/dim] {c}")
+    while True:
+        val = ask(prompt)
+        if val in choices:
+            return val
+        try:
+            idx = int(val) - 1
+            if 0 <= idx < len(choices):
+                return choices[idx]
+        except ValueError:
+            pass
+        warn("Invalid choice, try again")
+
+
+def multi_choose(prompt: str, choices: list[str]) -> list[str]:
+    if _can_use_interactive_selector():
+        selected = questionary.checkbox(
+            f"  {prompt}",
+            choices=[Choice(title=c, value=c, checked=True) for c in choices],
+            qmark="",
+        ).ask()
+        return list(selected) if selected else choices
+
+    for i, c in enumerate(choices, 1):
+        console.print(f"  [dim]{i}.[/dim] {c}")
+    raw = ask(f"{prompt} (comma-separated numbers)")
+    selected = []
+    for part in raw.split(","):
+        part = part.strip()
+        if part in choices:
+            selected.append(part)
+        else:
+            try:
+                idx = int(part) - 1
+                if 0 <= idx < len(choices):
+                    selected.append(choices[idx])
+            except ValueError:
+                pass
+    return selected or choices
+
+
+def show_diff(diff_lines: list[str]) -> None:
+    if not diff_lines:
+        info("No differences")
+        return
+    text = Text()
+    for line in diff_lines:
+        line_str = line.rstrip("\n")
+        if line_str.startswith("+"):
+            text.append(line_str + "\n", style="green")
+        elif line_str.startswith("-"):
+            text.append(line_str + "\n", style="red")
+        elif line_str.startswith("@@"):
+            text.append(line_str + "\n", style="cyan")
+        else:
+            text.append(line_str + "\n")
+    console.print(Panel(text, title="diff", border_style="dim"))
+
+
+def skill_table(skills: list[dict[str, Any]], has_flavor_fn: Callable[[str], bool] | None = None) -> None:
+    if not skills:
+        info("No skills cooked yet. Run [bold]skillchef cook <source>[/bold] to get started.")
+        return
+    table = Table(show_header=True, header_style="bold", border_style="dim")
+    table.add_column("Name")
+    table.add_column("Source", style="dim")
+    table.add_column("Last Sync", style="dim")
+    table.add_column("Flavor", justify="center")
+    table.add_column("Platforms", style="dim")
+    for s in skills:
+        flavored = has_flavor_fn(s["name"]) if has_flavor_fn else False
+        flavor = "[green]yes[/green]" if flavored else "[dim]no[/dim]"
+        table.add_row(
+            s["name"],
+            _truncate(s.get("remote_url", ""), 40),
+            s.get("last_sync", "")[:10],
+            flavor,
+            ", ".join(s.get("platforms", [])),
+        )
+    console.print(table)
+
+
+def show_platforms(platforms: dict[str, Any]) -> None:
+    table = Table(show_header=False, border_style="dim", padding=(0, 2))
+    table.add_column("Platform", style="bold")
+    table.add_column("Path", style="dim")
+    table.add_column("Status")
+    for name, path in platforms.items():
+        exists = path.exists()
+        status = "[green]found[/green]" if exists else "[dim]will create[/dim]"
+        table.add_row(name, str(path), status)
+    console.print(table)
+
+
+def show_detected_keys(keys: list[tuple[str, str]]) -> None:
+    if not keys:
+        info("No LLM API keys detected in environment")
+        return
+    for env_var, provider in keys:
+        success(f"Detected [bold]{env_var}[/bold] ({provider})")
+
+
+def show_config_summary(cfg: dict[str, Any]) -> None:
+    console.print()
+    table = Table(show_header=False, border_style="dim", padding=(0, 2))
+    table.add_column("Key", style="bold")
+    table.add_column("Value")
+    table.add_row("Platforms", ", ".join(cfg.get("platforms", [])))
+    table.add_row("Editor", cfg.get("editor", ""))
+    table.add_row("AI Model", cfg.get("model", ""))
+    table.add_row("AI Key", cfg.get("llm_api_key_env", "") or "(auto)")
+    console.print(table)
+
+
+def spinner(msg: str) -> Any:
+    return console.status(f"[dim]{msg}[/dim]", spinner="dots")
+
+
+def show_skill_md(text: str, title: str = "SKILL.md") -> None:
+    console.print(Syntax(text, "markdown", theme="monokai", line_numbers=False, word_wrap=True))
+
+
+def _truncate(s: str, n: int) -> str:
+    return s if len(s) <= n else s[: n - 1] + "…"
+
+
+def _can_use_interactive_selector() -> bool:
+    return sys.stdin.isatty() and sys.stdout.isatty()

skillchef-0.2.0.dist-info/METADATA

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: skillchef
+Version: 0.2.0
+Summary: pyenv + git for agent skills. Cook, flavor, and sync skills from any source.
+License-Expression: MIT
+Requires-Python: >=3.11
+Requires-Dist: click>=8.3.1
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: litellm>=1.81.11
+Requires-Dist: questionary>=2.1.0
+Requires-Dist: rich>=14.3.2
+Requires-Dist: tomli-w>=1.2.0
+Provides-Extra: test
+Requires-Dist: pytest>=8.3.0; extra == 'test'

skillchef-0.2.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+skillchef/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+skillchef/cli.py,sha256=SV5JoWDizzLENtCz_7c5ChwClWu56100UXpmpsHxAJU,1347
+skillchef/config.py,sha256=QLvK59JD4LOkgYPC_LqAAnOSu_H3SX-hQmISV5qvay0,1221
+skillchef/llm.py,sha256=kghXXSUFBS_hy80jWZOohlnHCsrKBvWwG84HfQ4UUgU,2301
+skillchef/merge.py,sha256=FBz39zj9EiLlZ9TERNNEeu-tsCzDSyFLmpNriLdMq10,1411
+skillchef/remote.py,sha256=LQQuf1_QXPo_eq7x9Hvg6xhIasoZyOBBqoHJbothFDY,3404
+skillchef/store.py,sha256=84aNuV5xVzjkZnwP3XDTcyqif8-q1z1JCL9urlkr080,3792
+skillchef/ui.py,sha256=bs37Wjfjjo6Nn6-qikIwBgoThiT3UQhuyiuJVdTdjE0,5799
+skillchef/commands/__init__.py,sha256=tXh_fYTgRn7dx3D3f4D-GM0RJQI8Rul5WXo_JrQSArw,64
+skillchef/commands/common.py,sha256=nQU7YJvJKxE6JvcCtWBWNR47X_Vu5bQdJK-qGhW6kJk,666
+skillchef/commands/cook_cmd.py,sha256=hQH3XtniS0KDLqu8F5N2E84ZR5cGpGmGZx5aEp3T_tg,1233
+skillchef/commands/flavor_cmd.py,sha256=kPAz6yjvJMJuXrgTlODEkHETUuLlptoDPefaUNQ_owU,875
+skillchef/commands/init_cmd.py,sha256=IcSda7BvZo1WPb3jWtIiCGr03QXl20AYwmaCgcJUlK4,1621
+skillchef/commands/list_cmd.py,sha256=OrnevMhx7-JZ_HoKyvFeT5vO2nYalUZgEX27f9IeP0M,177
+skillchef/commands/remove_cmd.py,sha256=5Rl3el4tKkGfUix_yMwy6JAFCnJ4Yz6YIs8OEk88lcw,426
+skillchef/commands/sync_cmd.py,sha256=8He2EMahOUyZGGR1MsIeU6BmWG17IXWvImzzIxZnW_A,4006
+skillchef-0.2.0.dist-info/METADATA,sha256=lCcamuGS-3ApT3kcCkvoX2APKqJ1EOHUOof482rR6x4,435
+skillchef-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+skillchef-0.2.0.dist-info/entry_points.txt,sha256=Pn0OUlTS0yfVDC0-odzQndDKcuM0CCl-Yigf5EHUYa4,49
+skillchef-0.2.0.dist-info/RECORD,,

skillchef-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

skillchef-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+skillchef = skillchef.cli:main