skillbench-cli 0.1.0__py3-none-any.whl

skillbench/scaffold.py

@@ -0,0 +1,106 @@
+"""`skillbench init`: the project folder with defaults, sample tests and a sample repo."""
+
+from pathlib import Path
+
+from skillbench.config import CONFIG_FILE_NAME, PROJECT_DIR_NAME
+
+_CONFIG = """\
+# Defaults for every test in this folder. A test's own fields win over these,
+# and command-line flags (--model, --repeat) win over both.
+
+# model: claude-sonnet-5-5   # passed straight to claude
+timeout_s: 600               # seconds before one turn is stopped
+# repeat: 1                  # run every test N times (each run uses real quota)
+# min_pass_rate: 1.0         # with repeats: the share of runs that must pass
+# fixture: .                 # the repo tests work in when they don't name one ("." = this repo)
+"""
+
+_GITIGNORE = """\
+runs/
+"""
+
+_SKILL_TEST = """\
+# A skill test: skillbench invokes one skill directly and checks what it did.
+# Run it with:  skillbench skill
+#
+#   skill:    the skill's name, or its path in the repo. skillbench looks in .claude/skills/,
+#             skills/, .github/skills/ and any plugin, and builds the /command.
+#   input:    the text after the /command.
+#   fixture:  the repo the agent works in, copied to a temp folder first so nothing real is
+#             touched. "." is this repo, a path is a folder in it, a git URL is cloned:
+#               fixture: {git: https://github.com/you/app.git, ref: main}
+name: hello-greets-by-name
+skill: hello
+input: the platform team
+fixture: skillbench/fixtures/sample-repo
+assert:
+  - skill_invoked: hello
+  - final_text_contains: Hello
+  - tool_not_called: Write
+
+# Trigger tests: does the skill's description make the agent pick it? Each prompt is one
+# short run that stops as soon as the agent decides. Uncomment to try:
+# triggers:
+#   should: ["say hi to Ada for me"]
+#   should_not: ["what is 2 + 2?"]
+"""
+
+_AGENT_TEST = """\
+# An agent loop test: a normal prompt, nothing forced. Checks that the agent picked the right
+# skills and tools on its own and finished the job.
+# Run it with:  skillbench agent
+#
+#   answers:  replies sent one per turn when the agent stops to ask something.
+#   assert:   checks on what happened. tool_order passes if those tools were called in that
+#             order (other calls in between are fine).
+name: hello-loop
+prompt: Please greet the platform team for me.
+fixture: skillbench/fixtures/sample-repo
+answers: []
+assert:
+  - skill_invoked: hello
+  - skill_not_invoked: deploy
+  - tool_order: [Skill]
+  - final_text_contains: Hello
+"""
+
+_SAMPLE_REPO_README = """\
+# sample-repo
+
+A tiny repo for skillbench's sample tests. Point `fixture:` at your own repo instead.
+"""
+
+_SAMPLE_SKILL = """\
+---
+name: hello
+description: Greet a person or group by name. Use when asked to greet someone or say hello.
+---
+
+Reply with exactly one line, `Hello, <name>!`, using the name you were given.
+Do not create or edit any files.
+"""
+
+_FILES = {
+    CONFIG_FILE_NAME: _CONFIG,
+    ".gitignore": _GITIGNORE,
+    "skills/example.yaml": _SKILL_TEST,
+    "agent/example.yaml": _AGENT_TEST,
+    "fixtures/sample-repo/README.md": _SAMPLE_REPO_README,
+    "fixtures/sample-repo/.claude/skills/hello/SKILL.md": _SAMPLE_SKILL,
+}
+
+
+def scaffold(parent: Path) -> tuple[list[Path], list[Path]]:
+    """Write the project folder under `parent`, never overwriting a file. Returns (created,
+    already existing) paths."""
+    project_dir = parent / PROJECT_DIR_NAME
+    created, existing = [], []
+    for relative_path, content in _FILES.items():
+        path = project_dir / relative_path
+        if path.exists():
+            existing.append(path)
+            continue
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content, encoding="utf-8")
+        created.append(path)
+    return created, existing

skillbench/skills.py

@@ -0,0 +1,168 @@
+"""Finding the skills and plugins in a workspace repo, picking the one a test names, and making
+every skill visible to the agent CLI."""
+
+import json
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+import yaml
+
+_SKILL_FILE = "SKILL.md"
+_PLUGIN_MANIFEST = Path(".claude-plugin") / "plugin.json"
+_CLAUDE_SKILLS = Path(".claude") / "skills"
+_GITHUB_SKILLS = Path(".github") / "skills"
+_ROOT_SKILLS = Path("skills")
+# Plugins are looked for at the repo root and this many folders below it (e.g. plugins/foo).
+_PLUGIN_SEARCH_DEPTH = 3
+_SKIPPED_DIRS = frozenset({".git", "node_modules", ".venv", "venv", "__pycache__", "dist"})
+_GIT_EXCLUDE = Path(".git") / "info" / "exclude"
+
+
+class SkillNotFoundError(Exception):
+    """The skill a test names is not in the workspace, or more than one skill matches."""
+
+
+@dataclass(frozen=True)
+class FoundSkill:
+    name: str  # the skill's own name (frontmatter `name:`, else its folder name)
+    directory: Path  # the folder holding SKILL.md
+    plugin_name: str | None = None  # set for a skill that ships inside a plugin
+
+    @property
+    def qualified_name(self) -> str:
+        return f"{self.plugin_name}:{self.name}" if self.plugin_name else self.name
+
+    @property
+    def invocation(self) -> str:
+        """The /command that runs this skill; a plugin's skills are prefixed with its name."""
+        return f"/{self.qualified_name}"
+
+
+@dataclass(frozen=True)
+class WorkspaceSkills:
+    plugin_dirs: list[Path]
+    skills: list[FoundSkill]
+
+
+def discover(workspace: Path) -> WorkspaceSkills:
+    """Every plugin and skill in the repo: in plugins, .claude/skills/, .github/skills/ and
+    skills/."""
+    plugin_dirs = _find_plugins(workspace)
+    skills = [
+        FoundSkill(_skill_name(skill_dir), skill_dir, _plugin_name(plugin_dir))
+        for plugin_dir in plugin_dirs
+        for skill_dir in _skill_dirs(plugin_dir / "skills")
+    ]
+    loose_roots = [_CLAUDE_SKILLS, _GITHUB_SKILLS]
+    if workspace not in plugin_dirs:  # a plugin at the root owns skills/
+        loose_roots.append(_ROOT_SKILLS)
+    skills += [
+        FoundSkill(_skill_name(skill_dir), skill_dir)
+        for root in loose_roots
+        for skill_dir in _skill_dirs(workspace / root)
+    ]
+    return WorkspaceSkills(plugin_dirs=plugin_dirs, skills=skills)
+
+
+def resolve(workspace: Path, found: WorkspaceSkills, wanted: str) -> FoundSkill:
+    """The skill a test's `skill:` names: a path inside the repo, `plugin:skill`, or a bare
+    skill name. Raises SkillNotFoundError if none or several match."""
+    is_path = "/" in wanted or "\\" in wanted
+    if is_path:
+        target = (workspace / wanted).resolve()
+        matches = [skill for skill in found.skills if skill.directory.resolve() == target]
+    else:
+        matches = [skill for skill in found.skills if wanted in (skill.name, skill.qualified_name)]
+    if len(matches) == 1:
+        return matches[0]
+    if not matches:
+        known = ", ".join(sorted({skill.qualified_name for skill in found.skills})) or "none"
+        looked = f"{_CLAUDE_SKILLS}/, {_GITHUB_SKILLS}/, {_ROOT_SKILLS}/ and plugins"
+        raise SkillNotFoundError(
+            f"skill '{wanted}' not found in the workspace (looked in {looked}; found: {known})"
+        )
+    candidates = "; ".join(
+        f"{skill.qualified_name} at {skill.directory.relative_to(workspace).as_posix()}"
+        for skill in matches
+    )
+    raise SkillNotFoundError(
+        f"skill '{wanted}' matches more than one skill ({candidates}); "
+        "use plugin:skill or the skill's path"
+    )
+
+
+def make_visible(workspace: Path, found: WorkspaceSkills) -> None:
+    """Copy skills Claude wouldn't find by itself into .claude/skills/. Plugins are passed by
+    flag instead. Copies are git-excluded so the agent sees a clean tree."""
+    for skill in found.skills:
+        if skill.plugin_name is not None:
+            continue
+        relative = skill.directory.relative_to(workspace)
+        if relative.parent == _CLAUDE_SKILLS:
+            continue
+        target = workspace / _CLAUDE_SKILLS / skill.directory.name
+        if target.exists():
+            continue
+        shutil.copytree(skill.directory, target)
+        _git_exclude(workspace, (_CLAUDE_SKILLS / skill.directory.name).as_posix())
+
+
+def _find_plugins(workspace: Path) -> list[Path]:
+    plugins = []
+    pending = [(workspace, 0)]
+    while pending:
+        directory, depth = pending.pop(0)
+        if (directory / _PLUGIN_MANIFEST).is_file():
+            plugins.append(directory)
+        if depth >= _PLUGIN_SEARCH_DEPTH:
+            continue
+        try:
+            children = sorted(entry for entry in directory.iterdir() if entry.is_dir())
+        except OSError:
+            continue
+        pending += [(child, depth + 1) for child in children if child.name not in _SKIPPED_DIRS]
+    return plugins
+
+
+def _skill_dirs(root: Path) -> list[Path]:
+    if not root.is_dir():
+        return []
+    return sorted(entry for entry in root.iterdir() if (entry / _SKILL_FILE).is_file())
+
+
+def _skill_name(skill_dir: Path) -> str:
+    frontmatter = _frontmatter(skill_dir / _SKILL_FILE)
+    name = frontmatter.get("name")
+    return name if isinstance(name, str) and name.strip() else skill_dir.name
+
+
+def _frontmatter(skill_file: Path) -> dict:
+    text = skill_file.read_text(encoding="utf-8", errors="replace")
+    if not text.startswith("---"):
+        return {}
+    end = text.find("\n---", 3)
+    if end == -1:
+        return {}
+    try:
+        parsed = yaml.safe_load(text[3:end])
+    except yaml.YAMLError:
+        return {}
+    return parsed if isinstance(parsed, dict) else {}
+
+
+def _plugin_name(plugin_dir: Path) -> str:
+    try:
+        manifest = json.loads((plugin_dir / _PLUGIN_MANIFEST).read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return plugin_dir.name
+    name = manifest.get("name") if isinstance(manifest, dict) else None
+    return name if isinstance(name, str) and name else plugin_dir.name
+
+
+def _git_exclude(workspace: Path, pattern: str) -> None:
+    exclude_file = workspace / _GIT_EXCLUDE
+    if not exclude_file.parent.is_dir():
+        return
+    with exclude_file.open("a", encoding="utf-8") as handle:
+        handle.write(f"/{pattern}/\n")

skillbench/workspace.py

@@ -0,0 +1,124 @@
+"""Creating the fresh temp workspace each run happens in, from a local folder or a git repo."""
+
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+# git:// ssh:// https:// file://, scp-style user@host:path, or anything ending in .git
+_GIT_URL = re.compile(r"^(https?|ssh|git|file)://|^[\w.-]+@[\w.-]+:|\.git/?$")
+# Never let git stop to ask for a password: a headless run would hang on it.
+_GIT_ENV = {**os.environ, "GIT_TERMINAL_PROMPT": "0"}
+# Windows' 260-character path limit trips over deep repos without this; harmless elsewhere.
+_GIT_CONFIG = ["-c", "core.longpaths=true"]
+
+
+class FixtureError(Exception):
+    """The fixture could not be copied or cloned; the message says why."""
+
+
+@dataclass(frozen=True)
+class GitFixture:
+    url: str
+    ref: str | None = None  # branch, tag or commit; None = the default branch
+
+    def __str__(self) -> str:
+        return f"{self.url}@{self.ref}" if self.ref else self.url
+
+
+Fixture = Path | GitFixture
+
+
+def is_git_url(text: str) -> bool:
+    return bool(_GIT_URL.search(text))
+
+
+def create_workspace(fixture: Fixture | None, exclude: Path) -> tuple[Path, str | None]:
+    """Make a new temp dir (kept after the run) holding the fixture, with git initialised.
+    Returns it and, for a git fixture, the commit it was checked out at. `exclude` (the
+    skillbench folder) is never copied. Raises FixtureError."""
+    workspace = Path(tempfile.mkdtemp(prefix="skillbench-ws-"))
+    if isinstance(fixture, GitFixture):
+        return workspace, _clone(fixture, workspace)
+    if fixture is not None:
+        _copy_folder(fixture, workspace, exclude)
+    _git(["init", "--quiet"], workspace, "initialising the workspace")
+    return workspace, None
+
+
+def _clone(fixture: GitFixture, workspace: Path) -> str:
+    """Clone into the workspace, check out the ref if any, and return the commit."""
+    _git(["clone", "--quiet", fixture.url, "."], workspace, f"cloning {fixture.url}")
+    if fixture.ref is not None:
+        doing = f"checking out ref '{fixture.ref}' of {fixture.url}"
+        _git(["checkout", "--quiet", fixture.ref], workspace, doing)
+    return _git(["rev-parse", "HEAD"], workspace, f"reading the commit of {fixture.url}").strip()
+
+
+def _copy_folder(source: Path, workspace: Path, exclude: Path) -> None:
+    """Copy what git would see (tracked and untracked files, not ignored ones) when `source`
+    is in a git repo, otherwise everything; never the excluded folder, unless the fixture
+    lives inside it."""
+    excluded: Path | None = exclude.resolve()
+    if source.resolve().is_relative_to(excluded):
+        excluded = None
+    listed = _git_visible_files(source)
+    if listed is None:
+        ignore = None if excluded is None else _ignore_path(excluded)
+        shutil.copytree(source, workspace, dirs_exist_ok=True, ignore=ignore)
+        return
+    for relative in listed:
+        file_path = source / relative
+        is_excluded = excluded is not None and file_path.resolve().is_relative_to(excluded)
+        if file_path.is_file() and not is_excluded:  # tracked files may be deleted locally
+            target = workspace / relative
+            target.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(file_path, target)
+
+
+def _git_visible_files(source: Path) -> list[str] | None:
+    """Paths relative to `source`, or None if it isn't inside a git work tree."""
+    try:
+        listed = subprocess.run(
+            ["git", "ls-files", "-z", "--cached", "--others", "--exclude-standard"],
+            cwd=source,
+            capture_output=True,
+            env=_GIT_ENV,
+            check=False,
+        )
+    except OSError:
+        return None
+    if listed.returncode != 0:
+        return None
+    return [path for path in listed.stdout.decode("utf-8").split("\0") if path]
+
+
+def _ignore_path(excluded: Path):
+    """A copytree `ignore` that skips one folder."""
+
+    def ignore(directory: str, names: list[str]) -> list[str]:
+        return [name for name in names if (Path(directory) / name).resolve() == excluded]
+
+    return ignore
+
+
+def _git(args: list[str], cwd: Path, doing: str) -> str:
+    """Run git and return its stdout. Raises FixtureError saying what was being done."""
+    try:
+        completed = subprocess.run(
+            ["git", *_GIT_CONFIG, *args],
+            cwd=cwd,
+            stdin=subprocess.DEVNULL,
+            capture_output=True,
+            env=_GIT_ENV,
+            check=False,
+        )
+    except OSError as error:
+        raise FixtureError(f"{doing}: git could not be run ({error})") from error
+    if completed.returncode != 0:
+        detail = completed.stderr.decode("utf-8", errors="replace").strip()
+        raise FixtureError(f"{doing} failed: {detail or f'git exited {completed.returncode}'}")
+    return completed.stdout.decode("utf-8", errors="replace")

skillbench_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,218 @@
+Metadata-Version: 2.5
+Name: skillbench-cli
+Version: 0.1.0
+Summary: Test your Claude Code skills and agent workflows, the way you test code.
+Project-URL: Homepage, https://github.com/adamsaul314/skillbench
+Project-URL: Issues, https://github.com/adamsaul314/skillbench/issues
+Author: Adam Saul
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,claude,claude-code,evals,skills,testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.11
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.7
+Description-Content-Type: text/markdown
+
+# skillbench
+
+Test your Claude Code skills and agent workflows, the way you test code.
+
+You write a small YAML file that says *"send this to Claude, then check these things"*. skillbench runs Claude Code for real on a copy of your repo, records everything it did, and tells you **pass** or **fail**.
+
+---
+
+## 1. Install
+
+You need Python 3.11+, git, and Claude Code installed and logged in (check with `claude --version`). Then install with whichever tool you use:
+
+```
+pip install skillbench-cli
+pipx install skillbench-cli
+uv tool install skillbench-cli
+```
+
+The command is `skillbench` either way. To try it without installing: `uvx --from skillbench-cli skillbench init`.
+
+## 2. Try it (2 minutes)
+
+In your repo:
+
+```
+skillbench init      # creates a skillbench/ folder with two example tests
+skillbench skill     # runs the skill test
+skillbench agent     # runs the agent test
+```
+
+You'll see something like:
+
+```
+[1/1] hello-greets-by-name  default model
+hello-greets-by-name: pass in 2.3s
+dashboard: skillbench/runs/index.html
+```
+
+Open `skillbench/runs/index.html` in your browser to see exactly what Claude did: every message, tool call and check.
+
+That's it. The rest of this page shows how to write your own tests.
+
+---
+
+## 3. Two kinds of test
+
+| | **Skill test** | **Agent test** |
+|---|---|---|
+| Question it answers | "When my skill runs, does it do the right thing?" | "Given a normal request, does Claude pick the right skills and get the job done?" |
+| Lives in | `skillbench/skills/` | `skillbench/agent/` |
+| Run with | `skillbench skill` | `skillbench agent` |
+| You write | `skill:` and `input:` | `prompt:` |
+
+### A skill test
+
+`skillbench/skills/grilling.yaml`
+
+```yaml
+skill: grilling                 # your skill's name
+input: an idea for a todo app   # what to send it
+fixture: .                      # run it on a copy of this repo
+
+assert:
+  - final_text_contains: "Q1"
+  - tool_not_called: Write
+```
+
+skillbench finds the skill wherever it lives in your repo (`.claude/skills/`, `skills/`, `.github/skills/` or a plugin) and runs it as `/grilling an idea for a todo app`.
+
+### An agent test
+
+`skillbench/agent/csv-export.yaml`
+
+```yaml
+prompt: add CSV export to the report page
+fixture: .
+
+answers:                       # replies, sent one at a time when Claude asks something
+  - Yes to all your recommendations.
+  - approved
+
+assert:
+  - skill_invoked: planner
+  - tool_order: [Read, Edit, Bash]
+  - command_succeeds: python -m pytest -q
+```
+
+Nothing is forced here. Claude sees every skill in your repo and decides for itself, and the test checks what it chose.
+
+---
+
+## 4. Checks you can make
+
+Put any of these under `assert:`.
+
+| Check | Passes when |
+|---|---|
+| `skill_invoked: grilling` | Claude used that skill |
+| `skill_not_invoked: grilling` | Claude didn't use that skill |
+| `tool_order: [Read, Edit]` | Claude used these tools in this order (other tools in between are fine) |
+| `tool_not_called: Write` | Claude never used that tool |
+| `final_text_contains: "Done"` | Claude's last message contains the text |
+| `file_contains: {path: notes.md, text: "approved"}` | That file exists afterwards and contains the text |
+| `command_succeeds: python -m pytest -q` | The command runs successfully in the workspace afterwards |
+
+A test passes when every check passes.
+
+---
+
+## 5. Which repo Claude works in (`fixture:`)
+
+Claude always works on a **copy**, so your real files are never touched.
+
+| `fixture:` | Claude gets |
+|---|---|
+| *(leave it out)* | An empty folder |
+| `.` | A copy of your repo, including work you haven't committed |
+| `some/folder` | A copy of that folder |
+| `https://github.com/you/app.git` | A fresh clone |
+| `{git: https://github.com/you/app.git, ref: v1.2}` | A clone at that branch, tag or commit |
+
+Paths are relative to your repo root. The copy is kept after the run so you can look inside, and its path is in the dashboard.
+
+---
+
+## 6. Running tests
+
+```
+skillbench skill                 # all skill tests
+skillbench skill grilling        # just the tests for one skill (or one test by name)
+skillbench agent csv-export      # one agent test
+skillbench agent --repeat 5      # run each test 5 times
+skillbench agent --model claude-sonnet-5-5
+```
+
+While it runs you'll see the current test, what Claude is doing, and roughly how long is left.
+
+---
+
+## 7. More options
+
+You won't need these to start.
+
+**Check a skill gets picked on its own.** List prompts that should and shouldn't trigger it. Each runs briefly and stops as soon as Claude decides:
+
+```yaml
+skill: grilling
+triggers:
+  should: ["stress-test my plan"]
+  should_not: ["fix this typo"]
+```
+
+**Answer Claude yourself.** Add `interactive: true` and skillbench asks *you* in the terminal whenever Claude is waiting for a reply. Press Enter on an empty line to finish.
+
+**Check for flakiness.** Claude doesn't do exactly the same thing every time. `--repeat 5` (or `repeat: 5` in the test) runs it 5 times and shows how often each check passed. Add `min_pass_rate: 0.8` to pass when 4 out of 5 runs pass.
+
+**Set defaults for every test** in `skillbench/skillbench.yaml`:
+
+```yaml
+model: claude-sonnet-5-5
+timeout_s: 600        # seconds before a turn is stopped
+fixture: .
+repeat: 1
+min_pass_rate: 1.0
+```
+
+A test's own settings win over these, and command-line flags win over both.
+
+**All test fields:**
+
+| Field | Meaning |
+|---|---|
+| `skill` / `input` | Skill tests: which skill, and what to send it |
+| `prompt` | Agent tests: the first message |
+| `answers` | Replies sent one per turn |
+| `interactive` | Ask you in the terminal for replies |
+| `triggers` | Prompts that should / shouldn't pick the skill |
+| `fixture` | Which repo Claude works in |
+| `assert` | The checks |
+| `name` | A display name (defaults to the file name) |
+| `timeout_s`, `repeat`, `min_pass_rate` | As above |
+
+---
+
+## Good to know
+
+- **It costs real usage.** Every run is a real Claude session. Start with skill tests; long agent tests take longer and cost more.
+- **Your personal setup is ignored.** Only the skills and plugins in the repo being tested are loaded, so results don't depend on whose machine runs them.
+- **Only test repos you trust.** Claude has full tool access inside the copy, and `command_succeeds` runs commands there.
+- **`command_succeeds` uses your system shell** (`sh` on Mac/Linux, `cmd` on Windows), so keep commands simple if you share tests across systems.
+- **Results** are in `skillbench/runs/`, which is git-ignored. Each run has a `run.json` and Claude's raw output.
+
+| Status | Meaning |
+|---|---|
+| `pass` | Every check passed |
+| `fail` | Claude finished, but a check failed |
+| `error` | Claude crashed or timed out, or the skill or fixture couldn't be found |

skillbench_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+skillbench/__init__.py,sha256=xuhAlrEiq6nBnACBFYL-pqeeeQOC_KI__zriGl_y5HQ,51
+skillbench/assertions.py,sha256=QPeDuNGfpldW826wbS9qxsmuNeB-AwFXxWgz_8TcZ_c,9563
+skillbench/claude.py,sha256=xUrSihI1UjdC734pEWtnEnvB6BTg4MxaKyKN5ZlgbuA,10770
+skillbench/cli.py,sha256=JakEyZtrryVAQJXBy0ocgnWHf65Vtooqr6afvuWDGa0,12389
+skillbench/config.py,sha256=MPUvz1wyWUpZw_C-YI0p7CNa_0HW7Q9NFxjq1kqHmAQ,9947
+skillbench/dashboard.py,sha256=HUBG61uZ_qwNtwXdCMBnwp2yVjnY99BAY5ylPaN1MhA,24329
+skillbench/progress.py,sha256=0cc1CQM5ntDkY8rIfpEODmyw2UfjeHzgPaN-9yItrg4,7685
+skillbench/runner.py,sha256=vB_CuQ3qV_owufJAf88d5vK5upZ5ZZm3jpaOUHWyb9U,18305
+skillbench/scaffold.py,sha256=WgB-U8HoV75bkRDcPe_mCj5qUmjGCnQcmFkuK8HqRW8,3841
+skillbench/skills.py,sha256=Qio0am02G6tPg5dCNEiHcUMbvBjsgvZPqoXjbGqJHb8,6417
+skillbench/workspace.py,sha256=F2WCfvlV7JuEfvWkJ2r0zy6BO8KTcSE2725fSwQjdlg,4881
+skillbench_cli-0.1.0.dist-info/METADATA,sha256=26gJCU48lMHOvvI2CPMhWAuVe3aFicIjgUhwgu6ALPE,7503
+skillbench_cli-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+skillbench_cli-0.1.0.dist-info/entry_points.txt,sha256=YtKWfB9WaELMltae7MJnMmUL37oJXoyDWr3uOb2P4FU,51
+skillbench_cli-0.1.0.dist-info/licenses/LICENSE,sha256=gABCeZ1x3voBu99KF6B55f6HGNdEiOpMKi5ZsBAveLg,1066
+skillbench_cli-0.1.0.dist-info/RECORD,,

skillbench_cli-0.1.0.dist-info/WHEEL

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

skillbench_cli-0.1.0.dist-info/entry_points.txt

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

skillbench_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Adam Saul
+
+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.