skeel 0.1.0__tar.gz

skeel-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.ruff_cache/
+.venv/
+dist/
+*.egg-info/

skeel-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matthias Vallentin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

skeel-0.1.0/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: skeel
+Version: 0.1.0
+Summary: Declarative agent skill manager with pluggable backends.
+Project-URL: Homepage, https://github.com/mavam/skeel
+Project-URL: Repository, https://github.com/mavam/skeel
+Project-URL: Bug Tracker, https://github.com/mavam/skeel/issues
+Author: Matthias Vallentin
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent-skills,agents,cli,github-cli,skills
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Version Control
+Classifier: Typing :: Typed
+Requires-Python: <3.15,>=3.14
+Requires-Dist: pyyaml>=6.0.2
+Description-Content-Type: text/markdown
+
+# 🛠️ skeel
+
+Declarative agent skill management.
+
+**skeel** reads a desired-state manifest and applies it through a backend.
+
+The first backend is `gh skill` from GitHub CLI.
+
+## ✨ Features
+
+- **Desired state**: declare skills, sources, shared install directory, and
+  target agents in one YAML file
+- **Plan and diff**: preview commands and compare managed skills against what's
+  installed locally
+- **Apply and update**: install missing skills and update gh-managed skills
+- **Agent links**: installs once into a shared directory and links skills into
+  agent-specific locations such as Claude Code
+
+## 🚀 Quickstart
+
+Run `skeel` directly with `uvx`:
+
+```sh
+uvx skeel --help
+```
+
+## ⚙️ Manifest
+
+Default path: `~/.agents/.skill.yaml`
+
+```yaml
+version: 1
+shared_dir: ~/.agents/skills
+agents:
+  - universal
+  - claude-code
+sources:
+  - source: openclaw/gogcli
+    allow_hidden_dirs: true
+    skills:
+      - gog
+```
+
+## ✨ Usage
+
+```sh
+uvx skeel plan    # print commands
+uvx skeel diff    # compare desired vs installed skills
+uvx skeel apply   # install desired state
+uvx skeel update  # update installed gh-managed skills
+uvx skeel path    # print manifest path
+```
+
+## 🧰 Backend policy
+
+`skeel` installs each skill into the shared directory with:
+
+```sh
+gh skill install <repo> <skill> --dir ~/.agents/skills --force
+```
+
+For `claude-code`, it creates symlinks from `~/.claude/skills/<skill>` to the
+shared skill directory.
+
+## 📄 License
+
+[MIT](LICENSE)

skeel-0.1.0/README.md

@@ -0,0 +1,67 @@
+# 🛠️ skeel
+
+Declarative agent skill management.
+
+**skeel** reads a desired-state manifest and applies it through a backend.
+
+The first backend is `gh skill` from GitHub CLI.
+
+## ✨ Features
+
+- **Desired state**: declare skills, sources, shared install directory, and
+  target agents in one YAML file
+- **Plan and diff**: preview commands and compare managed skills against what's
+  installed locally
+- **Apply and update**: install missing skills and update gh-managed skills
+- **Agent links**: installs once into a shared directory and links skills into
+  agent-specific locations such as Claude Code
+
+## 🚀 Quickstart
+
+Run `skeel` directly with `uvx`:
+
+```sh
+uvx skeel --help
+```
+
+## ⚙️ Manifest
+
+Default path: `~/.agents/.skill.yaml`
+
+```yaml
+version: 1
+shared_dir: ~/.agents/skills
+agents:
+  - universal
+  - claude-code
+sources:
+  - source: openclaw/gogcli
+    allow_hidden_dirs: true
+    skills:
+      - gog
+```
+
+## ✨ Usage
+
+```sh
+uvx skeel plan    # print commands
+uvx skeel diff    # compare desired vs installed skills
+uvx skeel apply   # install desired state
+uvx skeel update  # update installed gh-managed skills
+uvx skeel path    # print manifest path
+```
+
+## 🧰 Backend policy
+
+`skeel` installs each skill into the shared directory with:
+
+```sh
+gh skill install <repo> <skill> --dir ~/.agents/skills --force
+```
+
+For `claude-code`, it creates symlinks from `~/.claude/skills/<skill>` to the
+shared skill directory.
+
+## 📄 License
+
+[MIT](LICENSE)

skeel-0.1.0/examples/skills.yaml

@@ -0,0 +1,18 @@
+version: 1
+shared_dir: ~/.agents/skills
+agents:
+  - universal
+  - claude-code
+sources:
+  - source: mavam/skills
+    private: true
+    skills:
+      - mavam
+  - source: openclaw/gogcli
+    allow_hidden_dirs: true
+    skills:
+      - gog
+  - source: anthropics/skills
+    skills:
+      - frontend-design
+      - skill-creator

skeel-0.1.0/pyproject.toml

@@ -0,0 +1,113 @@
+[build-system]
+requires = ["hatchling>=1.25.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "skeel"
+version = "0.1.0"
+description = "Declarative agent skill manager with pluggable backends."
+readme = "README.md"
+requires-python = ">=3.14,<3.15"
+license = "MIT"
+authors = [{ name = "Matthias Vallentin" }]
+keywords = ["agent-skills", "agents", "cli", "github-cli", "skills"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.14",
+  "Topic :: Software Development :: Version Control",
+  "Typing :: Typed",
+]
+dependencies = ["PyYAML>=6.0.2"]
+
+[project.urls]
+Homepage = "https://github.com/mavam/skeel"
+Repository = "https://github.com/mavam/skeel"
+"Bug Tracker" = "https://github.com/mavam/skeel/issues"
+
+[project.scripts]
+skeel = "skeel.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/skeel"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "/src/**/*",
+  "/tests",
+  "/examples",
+  "/README.md",
+  "/LICENSE",
+  "/pyproject.toml",
+]
+exclude = [
+  "*.pyc",
+  "__pycache__",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".ruff_cache",
+]
+
+[dependency-groups]
+dev = [
+  "coverage[toml]>=7.6.0",
+  "lefthook>=2.1.6",
+  "mypy>=1.11.0",
+  "pytest>=8.0",
+  "pytest-cov>=5.0.0",
+  "ruff>=0.8.0",
+  "tenzir-ship>=1.8.0",
+  "types-PyYAML>=6.0.12.20250915",
+]
+
+[tool.ruff]
+target-version = "py314"
+line-length = 100
+src = ["src"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+line-ending = "lf"
+
+[tool.pytest.ini_options]
+minversion = "8.0"
+addopts = "-ra --strict-markers"
+testpaths = ["tests"]
+python_files = ["test_*.py", "*_test.py"]
+pythonpath = ["src"]
+
+[tool.mypy]
+files = ["src"]
+python_version = "3.14"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+check_untyped_defs = true
+disallow_untyped_decorators = true
+no_implicit_optional = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_no_return = true
+warn_unreachable = true
+strict_equality = true
+
+[tool.coverage.run]
+source = ["src/skeel"]
+branch = true
+omit = [
+  "*/tests/*",
+]
+
+[tool.coverage.report]
+fail_under = 80
+show_missing = true
+skip_covered = true

skeel-0.1.0/src/skeel/__init__.py

@@ -0,0 +1,3 @@
+"""Declarative agent skill management."""
+
+__version__ = "0.1.0"

skeel-0.1.0/src/skeel/backends.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+import os
+import shlex
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Protocol
+
+from .manifest import Manifest, SkillSpec, SourceSpec
+
+Command = list[str]
+
+
+@dataclass(frozen=True)
+class InstallStep:
+    label: str
+    command: Command
+
+
+class Backend(Protocol):
+    name: str
+
+    def install_steps(
+        self,
+        manifest: Manifest,
+        source: SourceSpec,
+        skill: SkillSpec,
+    ) -> list[InstallStep]: ...
+
+    def update_steps(self, manifest: Manifest) -> list[InstallStep]: ...
+
+
+def quote_command(command: Command) -> str:
+    return " ".join(shlex.quote(part) for part in command)
+
+
+class Runner:
+    def __init__(self, *, dry_run: bool = False) -> None:
+        self.dry_run = dry_run
+
+    def run(self, step: InstallStep, *, keep_going: bool = False) -> int:
+        print(quote_command(step.command))
+        if self.dry_run:
+            return 0
+        result = subprocess.run(step.command, check=False)
+        if result.returncode and not keep_going:
+            raise SystemExit(result.returncode)
+        return result.returncode
+
+
+class GhSkillBackend:
+    name = "gh"
+
+    def install_steps(
+        self,
+        manifest: Manifest,
+        source: SourceSpec,
+        skill: SkillSpec,
+    ) -> list[InstallStep]:
+        command = [
+            "gh",
+            "skill",
+            "install",
+            source.source,
+            skill.spec,
+            "--dir",
+            str(manifest.shared_dir),
+            "--force",
+        ]
+        if source.allow_hidden_dirs:
+            command.append("--allow-hidden-dirs")
+        if skill.pin:
+            command.extend(["--pin", skill.pin])
+        return [InstallStep(label=f"{source.source}/{skill.spec}", command=command)]
+
+    def update_steps(self, manifest: Manifest) -> list[InstallStep]:
+        return [
+            InstallStep(
+                label="gh skill update",
+                command=["gh", "skill", "update", "--all", "--dir", str(manifest.shared_dir)],
+            )
+        ]
+
+
+_BACKENDS: dict[str, Backend] = {
+    GhSkillBackend.name: GhSkillBackend(),
+}
+
+
+def get_backend(name: str) -> Backend:
+    try:
+        return _BACKENDS[name]
+    except KeyError as error:
+        supported = ", ".join(sorted(_BACKENDS))
+        message = f"unsupported backend {name!r}; supported backends: {supported}"
+        raise ValueError(message) from error
+
+
+def symlink_step(manifest: Manifest, skill: SkillSpec) -> InstallStep | None:
+    if "claude-code" not in manifest.agents:
+        return None
+    source = manifest.shared_dir / skill.name
+    target = manifest.claude_dir / skill.name
+    rel = os.path.relpath(source, start=target.parent)
+    return InstallStep(
+        label=f"link claude-code/{skill.name}",
+        command=["ln", "-sfn", rel, str(target)],
+    )
+
+
+def ensure_claude_symlink(manifest: Manifest, skill: SkillSpec) -> None:
+    if "claude-code" not in manifest.agents:
+        return
+    source = manifest.shared_dir / skill.name
+    target = manifest.claude_dir / skill.name
+    if not source.exists():
+        raise SystemExit(f"cannot link missing skill: {source}")
+    target.parent.mkdir(parents=True, exist_ok=True)
+    rel = os.path.relpath(source, start=target.parent)
+    if target.is_symlink() or target.exists():
+        if target.is_dir() and not target.is_symlink():
+            subprocess.run(["rm", "-rf", str(target)], check=True)
+        else:
+            target.unlink()
+    target.symlink_to(rel, target_is_directory=True)
+
+
+def installed_skill_names(path: Path) -> set[str]:
+    if not path.exists():
+        return set()
+    return {item.name for item in path.iterdir() if item.is_dir() and (item / "SKILL.md").exists()}

skeel-0.1.0/src/skeel/cli.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from collections.abc import Iterator
+
+from . import __version__
+from .backends import (
+    InstallStep,
+    Runner,
+    ensure_claude_symlink,
+    get_backend,
+    installed_skill_names,
+    quote_command,
+    symlink_step,
+)
+from .manifest import Manifest, load_manifest, manifest_path
+
+
+def use_color() -> bool:
+    return os.environ.get("NO_COLOR") is None
+
+
+def red(text: str) -> str:
+    return f"\033[31m{text}\033[0m" if use_color() else text
+
+
+def green(text: str) -> str:
+    return f"\033[32m{text}\033[0m" if use_color() else text
+
+
+def diff_sets(manifest: Manifest) -> tuple[list[str], list[str]]:
+    desired = manifest.desired_skill_names
+    installed = installed_skill_names(manifest.shared_dir)
+    return sorted(desired - installed), sorted(installed - desired)
+
+
+def print_diff(manifest: Manifest, *, warning: bool = False) -> bool:
+    missing, extra = diff_sets(manifest)
+    if not missing and not extra:
+        return False
+    if warning:
+        print(f"⚠️  Installed skills differ from {manifest.path}:", file=sys.stderr)
+    for name in missing:
+        print(red(f"- {name}"), file=sys.stderr)
+    for name in extra:
+        print(green(f"+ {name}"), file=sys.stderr)
+    return True
+
+
+def iter_install_plan(manifest: Manifest) -> Iterator[InstallStep]:
+    for source in manifest.sources:
+        backend = get_backend(source.backend)
+        for skill in source.skills:
+            yield from backend.install_steps(manifest, source, skill)
+            if step := symlink_step(manifest, skill):
+                yield step
+
+
+def command_plan(manifest: Manifest) -> int:
+    for step in iter_install_plan(manifest):
+        print(quote_command(step.command))
+    return 0
+
+
+def command_diff(manifest: Manifest) -> int:
+    return 1 if print_diff(manifest) else 0
+
+
+def command_apply(manifest: Manifest, *, dry_run: bool = False) -> int:
+    print_diff(manifest, warning=True)
+    runner = Runner(dry_run=dry_run)
+    for source in manifest.sources:
+        backend = get_backend(source.backend)
+        for skill in source.skills:
+            for step in backend.install_steps(manifest, source, skill):
+                print(f"📦 Installing {step.label} → {manifest.shared_dir}…")
+                runner.run(step)
+            if not dry_run:
+                ensure_claude_symlink(manifest, skill)
+            else:
+                link_step = symlink_step(manifest, skill)
+                if link_step:
+                    print(quote_command(link_step.command))
+    print("✅ Skills applied.")
+    return 0
+
+
+def command_update(manifest: Manifest, *, dry_run: bool = False) -> int:
+    print_diff(manifest, warning=True)
+    runner = Runner(dry_run=dry_run)
+    backends = {source.backend for source in manifest.sources}
+    print("🧠 Updating skills…")
+    for backend_name in sorted(backends):
+        backend = get_backend(backend_name)
+        for step in backend.update_steps(manifest):
+            runner.run(step, keep_going=True)
+    print("✅ Skills updated.")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Declarative agent skill manager")
+    parser.add_argument("--version", action="version", version=__version__)
+    parser.add_argument("--config", "-c", help="Manifest path (default: ~/.agents/.skill.yaml)")
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Print commands without applying changes",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+    for name in ["path", "plan", "diff", "apply", "sync", "update"]:
+        subparsers.add_parser(name)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    command = args.command or "plan"
+    path = manifest_path(args.config)
+
+    if command == "path":
+        print(path)
+        return 0
+
+    try:
+        manifest = load_manifest(path)
+    except Exception as error:
+        print(f"skeel: {error}", file=sys.stderr)
+        return 2
+
+    if command == "plan":
+        return command_plan(manifest)
+    if command == "diff":
+        return command_diff(manifest)
+    if command in {"apply", "sync"}:
+        return command_apply(manifest, dry_run=args.dry_run)
+    if command == "update":
+        return command_update(manifest, dry_run=args.dry_run)
+
+    parser.error(f"unknown command: {command}")
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

skeel-0.1.0/src/skeel/manifest.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+DEFAULT_MANIFEST = "~/.agents/.skill.yaml"
+DEFAULT_SHARED_DIR = "~/.agents/skills"
+DEFAULT_CLAUDE_DIR = "~/.claude/skills"
+
+
+@dataclass(frozen=True)
+class SkillSpec:
+    spec: str
+    name: str
+    pin: str | None = None
+
+
+@dataclass(frozen=True)
+class SourceSpec:
+    source: str
+    skills: tuple[SkillSpec, ...]
+    backend: str = "gh"
+    allow_hidden_dirs: bool = False
+    private: bool = False
+    pin: str | None = None
+
+
+@dataclass(frozen=True)
+class Manifest:
+    path: Path
+    agents: tuple[str, ...]
+    sources: tuple[SourceSpec, ...]
+    shared_dir: Path = field(default_factory=lambda: Path(DEFAULT_SHARED_DIR).expanduser())
+    claude_dir: Path = field(default_factory=lambda: Path(DEFAULT_CLAUDE_DIR).expanduser())
+
+    @property
+    def desired_skill_names(self) -> set[str]:
+        return {skill.name for source in self.sources for skill in source.skills}
+
+
+def manifest_path(value: str | None = None) -> Path:
+    if value:
+        return Path(value).expanduser()
+    return Path(os.environ.get("SKEEL_MANIFEST", DEFAULT_MANIFEST)).expanduser()
+
+
+def infer_skill_name(spec: str) -> str:
+    spec = spec.split("@", 1)[0].rstrip("/")
+    if spec == "*":
+        raise ValueError("wildcard skills are not supported; list desired skills explicitly")
+    if spec.endswith("/SKILL.md"):
+        return Path(spec).parent.name
+    if spec == "SKILL.md":
+        raise ValueError("root SKILL.md entries require an explicit name")
+    return Path(spec).name
+
+
+def parse_skill(value: Any, *, source_pin: str | None = None) -> SkillSpec:
+    if isinstance(value, str):
+        return SkillSpec(spec=value, name=infer_skill_name(value), pin=source_pin)
+    if not isinstance(value, dict):
+        raise ValueError(f"invalid skill entry: {value!r}")
+
+    spec = str(value.get("spec") or value.get("path") or value.get("name") or "")
+    if not spec:
+        raise ValueError(f"skill entry missing name/spec/path: {value!r}")
+    name = str(value.get("name") or infer_skill_name(spec))
+    pin = value.get("pin", source_pin)
+    return SkillSpec(spec=spec, name=name, pin=str(pin) if pin else None)
+
+
+def parse_source(value: Any) -> SourceSpec:
+    if not isinstance(value, dict):
+        raise ValueError(f"invalid source entry: {value!r}")
+    source = str(value.get("source") or "")
+    if not source:
+        raise ValueError(f"source entry missing source: {value!r}")
+    backend = str(value.get("backend") or "gh")
+    source_pin = value.get("pin")
+    pin = str(source_pin) if source_pin else None
+    skills = tuple(parse_skill(skill, source_pin=pin) for skill in value.get("skills") or [])
+    if not skills:
+        raise ValueError(f"source {source} has no skills")
+    return SourceSpec(
+        source=source,
+        skills=skills,
+        backend=backend,
+        allow_hidden_dirs=bool(value.get("allow_hidden_dirs") or value.get("allow-hidden-dirs")),
+        private=bool(value.get("private")),
+        pin=str(source_pin) if source_pin else None,
+    )
+
+
+def load_manifest(path: Path) -> Manifest:
+    data = yaml.safe_load(path.read_text())
+    if not isinstance(data, dict):
+        raise ValueError(f"manifest must be a YAML mapping: {path}")
+
+    agents = tuple(str(agent) for agent in data.get("agents") or [])
+    if not agents:
+        raise ValueError("manifest must define at least one agent")
+
+    sources = tuple(parse_source(source) for source in data.get("sources") or [])
+    if not sources:
+        raise ValueError("manifest must define at least one source")
+
+    return Manifest(
+        path=path,
+        agents=agents,
+        sources=sources,
+        shared_dir=Path(str(data.get("shared_dir") or DEFAULT_SHARED_DIR)).expanduser(),
+        claude_dir=Path(str(data.get("claude_dir") or DEFAULT_CLAUDE_DIR)).expanduser(),
+    )

skeel-0.1.0/tests/test_backends.py

@@ -0,0 +1,59 @@
+from pathlib import Path
+
+from skeel.backends import GhSkillBackend, quote_command, symlink_step
+from skeel.manifest import Manifest, SkillSpec, SourceSpec
+
+
+def test_gh_install_step() -> None:
+    manifest = Manifest(
+        path=Path("manifest.yaml"),
+        agents=("universal", "claude-code"),
+        sources=(),
+        shared_dir=Path("/tmp/agents/skills"),
+        claude_dir=Path("/tmp/claude/skills"),
+    )
+    source = SourceSpec(
+        source="openclaw/gogcli",
+        skills=(SkillSpec(spec="gog", name="gog"),),
+        allow_hidden_dirs=True,
+    )
+
+    step = GhSkillBackend().install_steps(manifest, source, source.skills[0])[0]
+
+    assert step.command == [
+        "gh",
+        "skill",
+        "install",
+        "openclaw/gogcli",
+        "gog",
+        "--dir",
+        "/tmp/agents/skills",
+        "--force",
+        "--allow-hidden-dirs",
+    ]
+
+
+def test_symlink_step_for_claude_code() -> None:
+    manifest = Manifest(
+        path=Path("manifest.yaml"),
+        agents=("universal", "claude-code"),
+        sources=(),
+        shared_dir=Path("/Users/me/.agents/skills"),
+        claude_dir=Path("/Users/me/.claude/skills"),
+    )
+
+    step = symlink_step(manifest, SkillSpec(spec="mavam", name="mavam"))
+
+    assert step is not None
+    assert step.command == [
+        "ln",
+        "-sfn",
+        "../../.agents/skills/mavam",
+        "/Users/me/.claude/skills/mavam",
+    ]
+
+
+def test_quote_command() -> None:
+    assert quote_command(["gh", "skill", "install", "owner/repo", "skills/foo/SKILL.md"]) == (
+        "gh skill install owner/repo skills/foo/SKILL.md"
+    )

skeel-0.1.0/tests/test_manifest.py

@@ -0,0 +1,47 @@
+from pathlib import Path
+
+import pytest
+
+from skeel.manifest import infer_skill_name, load_manifest
+
+
+def test_infer_skill_name_from_plain_name() -> None:
+    assert infer_skill_name("mavam") == "mavam"
+
+
+def test_infer_skill_name_from_skill_path() -> None:
+    assert infer_skill_name("skills/foo/SKILL.md") == "foo"
+
+
+def test_wildcard_is_rejected() -> None:
+    with pytest.raises(ValueError, match="wildcard"):
+        infer_skill_name("*")
+
+
+def test_load_manifest(tmp_path: Path) -> None:
+    manifest_path = tmp_path / "skills.yaml"
+    manifest_path.write_text(
+        """
+version: 1
+shared_dir: ~/.agents/skills
+agents:
+  - universal
+  - claude-code
+sources:
+  - source: mavam/skills
+    private: true
+    skills:
+      - mavam
+  - source: openclaw/gogcli
+    allow-hidden-dirs: true
+    skills:
+      - gog
+""".strip()
+    )
+
+    manifest = load_manifest(manifest_path)
+
+    assert manifest.path == manifest_path
+    assert manifest.agents == ("universal", "claude-code")
+    assert manifest.desired_skill_names == {"mavam", "gog"}
+    assert manifest.sources[1].allow_hidden_dirs is True