skillproof 0.1.0__py3-none-any.whl

skillproof/stats.py

@@ -0,0 +1,228 @@
+"""Turning trial results into numbers: pass rate, lift, trigger rate, deltas.
+
+Conventions:
+  * Errored runs (infrastructure failures) are excluded from every rate.
+  * Timed-out runs count as failures (the agent didn't finish).
+  * Rates are fractions in [0, 1]; lift is a difference of fractions
+    (+0.23 means "23 percentage points better with the skill").
+  * Token, cost and latency deltas are relative: +0.10 means 10% more with the skill.
+  * Intervals are 95%: Wilson score intervals for pass rates and Newcombe's
+    method (built from the two Wilson intervals) for the lift. Both behave
+    sensibly at small n and at 0% / 100%, unlike the textbook normal formula.
+  * The headline (suite-level) lift pools every graded trial of the cases where
+    the skill should trigger, treating trials as independent. Negative cases
+    (`should_trigger: false`) only check that the skill does no harm, so they
+    are reported per case, not mixed into the headline. Cases with very
+    different difficulty make pooling approximate.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Literal
+
+from skillproof.results import CaseResult, SuiteResult, TrialResult
+
+Z_95 = 1.959964
+# Below this many completed runs per variant, results get a "small sample" note.
+MIN_RUNS_FOR_CONFIDENCE = 10
+# Below this many completed runs per variant, no helps/hurts verdict is given at all:
+# with 2/2 vs 0/2 the interval already excludes zero, but nobody should quote that.
+MIN_RUNS_FOR_VERDICT = 5
+
+Interval = tuple[float, float]
+Verdict = Literal["helps", "hurts", "no clear effect", "too few runs", "not measured"]
+
+
+def wilson_interval(successes: int, n: int, z: float = Z_95) -> Interval | None:
+    """95% Wilson score interval for a pass rate."""
+    if n == 0:
+        return None
+    p = successes / n
+    denom = 1 + z * z / n
+    center = (p + z * z / (2 * n)) / denom
+    half = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / denom
+    return max(0.0, center - half), min(1.0, center + half)
+
+
+def lift_interval(with_: VariantStats, without: VariantStats) -> Interval | None:
+    """95% interval for (pass rate with) - (pass rate without), Newcombe's hybrid score method."""
+    p1, p2 = with_.pass_rate, without.pass_rate
+    ci1, ci2 = with_.pass_interval, without.pass_interval
+    if p1 is None or p2 is None or ci1 is None or ci2 is None:
+        return None
+    (l1, u1), (l2, u2) = ci1, ci2
+    diff = p1 - p2
+    low = diff - math.sqrt((p1 - l1) ** 2 + (u2 - p2) ** 2)
+    high = diff + math.sqrt((u1 - p1) ** 2 + (p2 - l2) ** 2)
+    return low, high
+
+
+def verdict(lift: float | None, interval: Interval | None, runs: int) -> Verdict:
+    """`runs` is the smaller number of completed runs of the two variants."""
+    if lift is None or interval is None:
+        return "not measured"
+    if runs < MIN_RUNS_FOR_VERDICT:
+        return "too few runs"
+    if interval[0] > 0:
+        return "helps"
+    if interval[1] < 0:
+        return "hurts"
+    return "no clear effect"
+
+
+@dataclass
+class VariantStats:
+    runs: int  # completed runs (errors excluded)
+    errors: int
+    passed: int
+    triggered: int
+    trigger_known: int  # runs where the runner could tell whether the skill fired
+    mean_tokens: float | None
+    mean_cost_usd: float | None  # None unless every completed run reported a cost
+    mean_duration_s: float | None
+
+    @property
+    def pass_rate(self) -> float | None:
+        return self.passed / self.runs if self.runs else None
+
+    @property
+    def pass_interval(self) -> Interval | None:
+        return wilson_interval(self.passed, self.runs)
+
+    @property
+    def trigger_rate(self) -> float | None:
+        return self.triggered / self.trigger_known if self.trigger_known else None
+
+
+class _Deltas:
+    """Lift and relative deltas shared by case- and suite-level stats."""
+
+    with_skill: VariantStats
+    without_skill: VariantStats
+
+    @property
+    def graded(self) -> bool:
+        return True
+
+    @property
+    def lift(self) -> float | None:
+        if not self.graded:
+            return None
+        return _diff(self.with_skill.pass_rate, self.without_skill.pass_rate)
+
+    @property
+    def lift_interval(self) -> Interval | None:
+        if not self.graded:
+            return None
+        return lift_interval(self.with_skill, self.without_skill)
+
+    @property
+    def verdict(self) -> Verdict:
+        runs = min(self.with_skill.runs, self.without_skill.runs)
+        return verdict(self.lift, self.lift_interval, runs)
+
+    @property
+    def token_delta(self) -> float | None:
+        return _relative(self.with_skill.mean_tokens, self.without_skill.mean_tokens)
+
+    @property
+    def cost_delta(self) -> float | None:
+        return _relative(self.with_skill.mean_cost_usd, self.without_skill.mean_cost_usd)
+
+    @property
+    def latency_delta(self) -> float | None:
+        return _relative(self.with_skill.mean_duration_s, self.without_skill.mean_duration_s)
+
+
+@dataclass
+class CaseStats(_Deltas):
+    name: str
+    should_trigger: bool
+    has_assertions: bool
+    with_skill: VariantStats
+    without_skill: VariantStats
+
+    @property
+    def graded(self) -> bool:
+        return self.has_assertions
+
+
+@dataclass
+class SuiteStats(_Deltas):
+    cases: list[CaseStats]
+    with_skill: VariantStats  # pooled over graded should_trigger cases
+    without_skill: VariantStats
+    triggers: int  # skill fired, in with-skill runs of should_trigger cases
+    trigger_runs: int
+    false_triggers: int  # skill fired, in with-skill runs of should_trigger: false cases
+    false_trigger_runs: int
+    errors: int
+
+    @property
+    def min_runs(self) -> int:
+        """Fewest completed runs in any graded variant: the weakest link for confidence."""
+        counts = [
+            v.runs for c in self.cases if c.has_assertions for v in (c.with_skill, c.without_skill)
+        ]
+        return min(counts) if counts else 0
+
+
+def _diff(a: float | None, b: float | None) -> float | None:
+    return None if a is None or b is None else a - b
+
+
+def _relative(a: float | None, b: float | None) -> float | None:
+    if a is None or b is None or b == 0:
+        return None
+    return a / b - 1
+
+
+def _mean(values: list[float]) -> float | None:
+    return sum(values) / len(values) if values else None
+
+
+def variant_stats(trials: list[TrialResult]) -> VariantStats:
+    done = [t for t in trials if not t.errored]
+    known = [t for t in done if t.run.triggered is not None]
+    costs = [t.run.usage.cost_usd for t in done]
+    return VariantStats(
+        runs=len(done),
+        errors=len(trials) - len(done),
+        passed=sum(t.passed for t in done),
+        triggered=sum(bool(t.run.triggered) for t in known),
+        trigger_known=len(known),
+        mean_tokens=_mean([t.run.usage.total_tokens for t in done]),
+        mean_cost_usd=None if None in costs else _mean([c for c in costs if c is not None]),
+        mean_duration_s=_mean([t.run.duration_s for t in done]),
+    )
+
+
+def case_stats(case: CaseResult) -> CaseStats:
+    return CaseStats(
+        name=case.name,
+        should_trigger=case.should_trigger,
+        has_assertions=case.has_assertions,
+        with_skill=variant_stats(case.variant("with")),
+        without_skill=variant_stats(case.variant("without")),
+    )
+
+
+def suite_stats(suite: SuiteResult) -> SuiteStats:
+    cases = [case_stats(c) for c in suite.cases]
+    graded = [c for c in suite.cases if c.has_assertions and c.should_trigger]
+    if not graded:  # only negative cases: fall back to pooling everything graded
+        graded = [c for c in suite.cases if c.has_assertions]
+    positive = [s.with_skill for s in cases if s.should_trigger]
+    negative = [s.with_skill for s in cases if not s.should_trigger]
+    return SuiteStats(
+        cases=cases,
+        with_skill=variant_stats([t for c in graded for t in c.variant("with")]),
+        without_skill=variant_stats([t for c in graded for t in c.variant("without")]),
+        triggers=sum(v.triggered for v in positive),
+        trigger_runs=sum(v.trigger_known for v in positive),
+        false_triggers=sum(v.triggered for v in negative),
+        false_trigger_runs=sum(v.trigger_known for v in negative),
+        errors=sum(s.with_skill.errors + s.without_skill.errors for s in cases),
+    )

skillproof-0.1.0.dist-info/METADATA

@@ -0,0 +1,262 @@
+Metadata-Version: 2.5
+Name: skillproof
+Version: 0.1.0
+Summary: pytest for agent skills: prove your skill actually works.
+Project-URL: Homepage, https://github.com/akhilgarg07/skillproof
+Project-URL: Issues, https://github.com/akhilgarg07/skillproof/issues
+Project-URL: Source, https://github.com/akhilgarg07/skillproof
+Author: Akhil Garg
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent-skills,claude-code,codex,evals,llm,testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Requires-Dist: anthropic>=1.15
+Requires-Dist: claude-agent-sdk>=0.2.168
+Requires-Dist: openai>=3.0
+Requires-Dist: pydantic>=2.6
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.7
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# skillproof
+
+**pytest for agent skills: prove your skill actually works.**
+
+[![ci](https://github.com/akhilgarg07/skillproof/actions/workflows/ci.yml/badge.svg)](https://github.com/akhilgarg07/skillproof/actions/workflows/ci.yml)
+[![license: MIT](https://img.shields.io/badge/license-MIT-blue)](https://github.com/akhilgarg07/skillproof/blob/main/LICENSE)
+
+![skillproof demo](https://raw.githubusercontent.com/akhilgarg07/skillproof/main/docs/demo.gif)
+<!-- Record with: vhs docs/demo.tape -->
+
+```bash
+pip install skillproof
+```
+
+**Works with:** Claude Code · Codex · any OpenAI-compatible endpoint
+
+---
+
+Agent skills (`SKILL.md` folders for Claude Code, Codex, Cursor, Gemini CLI,
+OpenCode...) are everywhere, but almost nobody can show that a skill helps. Often
+it isn't even loaded: the agent never decides to use it. **skillproof** runs your
+tasks N times **with** the skill installed and N times **without** it, then tells
+you:
+
+- **Trigger rate**: did the agent actually load the skill?
+- **Lift**: pass rate with the skill minus pass rate without it, with a 95% confidence interval
+- **Cost**: extra (or saved) tokens, dollars and seconds per run
+- **A verdict**: *helps*, *hurts*, *no clear effect*, or *too few runs* to say
+
+## 60-second quickstart
+
+```bash
+pip install skillproof
+export ANTHROPIC_API_KEY=sk-ant-...      # or use your `claude` login
+
+skillproof init ./my-skill                # writes my-skill/evals.yaml
+# edit evals.yaml: 2-3 real tasks, how to check them, one task the skill should ignore
+skillproof run ./my-skill                 # prints the plan and cost estimate, then runs
+```
+
+`uvx skillproof run ./my-skill` works too, without installing anything.
+
+## Example output
+
+This is a real run of the [`release-notes`](https://github.com/akhilgarg07/skillproof/blob/main/examples/release-notes/) example
+(Claude Code, 5 trials per variant):
+
+```
+acme-release-notes · runner claude-code · model claude-opus-5-5
+
+ case                             ┃        triggered ┃ pass with ┃ pass without ┃  lift ┃ tokens Δ ┃ latency Δ
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━╇━━━━━━━━━━━━━━╇━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━━
+ release notes from merged PRs    │              5/5 │       5/5 │          0/5 │ +100% │      +7% │       −3%
+ release with no breaking changes │              5/5 │       5/5 │          0/5 │ +100% │      +7% │       +3%
+ unrelated question               │ 0/5 (should not) │       4/5 │          5/5 │  −20% │      ±0% │       −2%
+
+skill lift: +100% (95% CI +61% to +100%)  |  triggers 10/10  |  false triggers 0/5  |  tokens +7%  |  cost +10%
+verdict: the skill helps (95% CI for lift: +61% to +100%)
+• Small sample: as few as 5 completed run(s) per variant. Treat these numbers as rough; use --trials 10 or more
+  before quoting them.
+```
+
+Every run also saves a self-contained **HTML report** (with each run's checks and
+answer), `report.md`, `summary.json` and the full transcripts under
+`.skillproof/runs/<timestamp>/`.
+
+[`examples/`](https://github.com/akhilgarg07/skillproof/blob/main/examples/) has skills that **help**, **do nothing** and **hurt**, so
+you can see all three outcomes.
+
+## How it works
+
+```
+for each case in evals.yaml, N trials, interleaved:
+    with skill:     fresh temp dir + fixtures + skill installed  ->  agent  ->  checks
+    without skill:  fresh temp dir + fixtures, no skill          ->  agent  ->  checks
+```
+
+- Every run gets a **fresh temp directory** with your fixtures copied in. Your
+  project is never touched.
+- Your **personal** skills, settings and instructions (`~/.claude`, `~/.codex`,
+  `~/.agents`) are not loaded for either variant, so the only difference is the skill.
+- The agent can't see your `evals.yaml` or its checks.
+- Transcripts, token usage and tool calls are saved for every run, with API keys redacted.
+
+## evals.yaml
+
+```yaml
+skill: ./                 # folder containing SKILL.md
+runner: claude-code       # claude-code | codex | openai-compatible
+# model: claude-sonnet-5-5  # optional; the agent's default otherwise
+trials: 5                 # runs per case, per variant
+timeout: 300              # seconds per run
+
+cases:
+  - name: "summarizes stack trace"
+    prompt: "Here is an error log in error.log. What's wrong?"  # don't name the skill
+    fixtures: ./fixtures/case1/     # copied into each run's temp dir
+    assert:
+      - type: contains
+        value: "NullPointerException"
+      - type: file_exists
+        path: fix.patch
+      - type: command               # runs in the temp dir; passes on exit code 0
+        run: "python -m pytest -q"
+      - type: max_tokens
+        value: 20000
+      - type: llm_judge             # optional; graded by a model from another vendor
+        rubric: "States the root cause in the first sentence."
+
+  - name: "unrelated question"      # catches skills that load when they shouldn't
+    prompt: "What's the capital of France?"
+    should_trigger: false
+    assert:
+      - {type: contains, value: "Paris"}
+```
+
+| assertion | passes when |
+|---|---|
+| `contains` / `not_contains` | the final answer contains / doesn't contain `value` (case-insensitive by default) |
+| `regex` | the final answer matches `pattern` |
+| `file_exists` / `file_contains` | a file in the temp dir exists / contains `value` |
+| `command` | `run` exits 0 in the temp dir (API keys are removed from its environment) |
+| `max_tokens` | the run used at most `value` tokens (input + output + cache) |
+| `llm_judge` | a judge model says the answer meets `rubric` |
+
+Use deterministic checks first. `llm_judge` defaults to a judge from a **different
+vendor** than the agent (Claude agents are graded by an OpenAI model and vice
+versa), so no model grades its own family. Change it with
+`judge: {provider: anthropic, model: ...}`.
+
+## Runners
+
+| runner | how it runs | where the skill goes | how a trigger is detected |
+|---|---|---|---|
+| `claude-code` | [Claude Agent SDK](https://code.claude.com/docs/en/agent-sdk/overview) | `<temp>/.claude/skills/<name>/` | a `Skill` tool call naming the skill |
+| `codex` | `codex exec --json` | `<temp>/.agents/skills/<name>/` | a shell command that reads the skill's folder |
+| `openai-compatible` | a small tool-using loop over Chat Completions | SKILL.md pasted into the system prompt | not measured (**approximate**) |
+
+Keys come from environment variables only: `ANTHROPIC_API_KEY` (or your `claude`
+login), `CODEX_API_KEY` / `OPENAI_API_KEY` (or `codex login`). Runner settings go
+under `runner_options:`; see each runner's module docstring.
+
+## Reports, CI and badges
+
+```bash
+skillproof run ./my-skill --format md -o report.md    # also: html, json (to stdout)
+skillproof report                                      # re-render the latest run
+skillproof run ./my-skill --min-lift 0 --min-trigger-rate 80   # exit 1 if not met
+skillproof run ./my-skill --dry-run                    # plan + cost estimate only
+```
+
+**Cost guard:** before every run skillproof prints the number of runs and an
+estimate based on your previous runs. Above $5 it asks first; in CI it refuses
+unless you pass `--yes`. If the first runs all fail (bad key, wrong model), it
+stops and tells you what to fix.
+
+**GitHub Action:** comments the results on pull requests and keeps the comment up to date.
+
+```yaml
+# .github/workflows/skillproof.yml (full example: action/example-workflow.yml)
+on: pull_request
+permissions: {contents: read, pull-requests: write}
+jobs:
+  skillproof:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: akhilgarg07/skillproof@v0
+        with: {path: my-skill, trials: "10", min-lift: "0"}
+        env: {ANTHROPIC_API_KEY: "${{ secrets.ANTHROPIC_API_KEY }}"}
+```
+
+**Badge for your skill's README:**
+
+```bash
+skillproof badge ./my-skill
+# [![skillproof: +100% lift · 10/10 triggered](https://img.shields.io/badge/skillproof-...-brightgreen)](...)
+```
+
+It is green when the skill helps, red when it hurts and grey when the result is
+not significant or comes from fewer than 5 runs per variant. `--json` prints a
+[shields.io endpoint](https://shields.io/badges/endpoint-badge) file instead, so CI
+can keep a badge up to date.
+
+## Honest numbers: what this can and can't tell you
+
+- **It measures your tasks, not the skill in general.** Lift depends on the prompts
+  and checks you write. Publish your `evals.yaml` next to any number you share.
+- **Small samples are noisy.** Every rate comes with a 95% interval (Wilson for pass
+  rates, Newcombe for the lift). Below 5 runs per variant there's no verdict at all,
+  and below 10 the report says the numbers are rough.
+- **Results depend on the agent and model.** Reports record the model that actually
+  ran. In our runs, Claude Code read a library's source, noticed that a skill's docs
+  were stale and ignored them ([`examples/stale-docs`](https://github.com/akhilgarg07/skillproof/blob/main/examples/stale-docs/)); a
+  weaker model may not.
+- **Trigger detection is per agent and heuristic.** Claude Code has an explicit
+  `Skill` tool call. Codex reads skills with ordinary shell commands, so a "trigger"
+  there means a command touched the skill's folder.
+- **The `openai-compatible` runner is an approximation.** It pastes SKILL.md into the
+  system prompt instead of letting the agent discover and load it, so it can't
+  measure trigger rate and overstates how often a skill is "used". Reports label it.
+- **Token deltas include cache reads,** which are cheap. Look at the cost delta when
+  the agent reports cost (Claude Code does).
+- **`llm_judge` is a model's opinion.** It's cross-vendor by default, but still noisy;
+  prefer deterministic checks.
+- **Agents run real commands.** Runs happen in temp directories, but agents run
+  without permission prompts, so a command could still reach other files on your
+  machine. Test untrusted skills in a container or VM.
+
+## Leaderboard
+
+[`leaderboard/`](https://github.com/akhilgarg07/skillproof/blob/main/leaderboard/) runs skillproof over a list of public skills (using
+evals you write, never the repo's own) and renders a markdown leaderboard.
+
+## Contributing
+
+Contributions are very welcome; see [CONTRIBUTING.md](https://github.com/akhilgarg07/skillproof/blob/main/CONTRIBUTING.md). Good first issues:
+
+- **New runners:** Gemini CLI, Cursor (cursor-agent), OpenCode, Aider
+- **New assertions:** `tool_called` (the agent used a given tool), `json_schema`,
+  `file_matches` (regex on a file), `max_cost_usd`
+- **`skillproof compare`:** two versions of a skill head to head
+- **Windows support** and a Docker sandbox option for untrusted skills
+- **A local judge:** `llm_judge` over Chat Completions, for local models (Ollama, vLLM)
+
+## License
+
+MIT

skillproof-0.1.0.dist-info/RECORD

@@ -0,0 +1,43 @@
+skillproof/__init__.py,sha256=urbrGjQfeu1ZUZxK0dyFbSxrMkLH2iPHa0--rCc3Zrs,66
+skillproof/__main__.py,sha256=bR8t5-IAeTrQgsQtfAzuhJldwIb50NjndGXut1PY-tU,40
+skillproof/cli.py,sha256=ib_UkGWnifJfmgPb02qOLpzjk6zP95iG9xZdHDSXe0Q,11629
+skillproof/config.py,sha256=Rev-0dMHmrienEBRKIZVzlJwX-XFvxvUn12eTU7nS-Y,7362
+skillproof/engine.py,sha256=g2GLad4sHow_aXDJoWp2d7P5gZmCWuAYyQN7hTi49yc,10407
+skillproof/errors.py,sha256=iX1u8jfRZdjJn_uf-EGlK91MCHKhpeNaW78v0nxFMv0,2334
+skillproof/estimate.py,sha256=kNSsheS9bvvRxUzmiDGTfWeLlW_suEGT6R5LLyE0ExI,3129
+skillproof/results.py,sha256=jWBqDDeUUcqd70PphXpMxFpjV5RMv-fdhqaws2W37eg,2930
+skillproof/sandbox.py,sha256=9i3UAxJDatlZpAbqaLIaFOavtwWp54RPkSvSuSdyklM,2921
+skillproof/scaffold.py,sha256=agvMzI_1H-g3xrm59XQdE8920ABhET49UsO9cURZ4W4,5482
+skillproof/skill.py,sha256=MpsFMYO-ouCcxgKFt8okEYRETxTkXSMSuCmQp-Z6cCI,3453
+skillproof/stats.py,sha256=QNYiB67Ylup0LU7UiX72aWxDmuITsWuKFumIuQVGJzg,8305
+skillproof/assertions/__init__.py,sha256=aHjMYvr4O7CLu4U9jupBDczvISs2ttuM8GH2PVCj2aY,1837
+skillproof/assertions/base.py,sha256=FaRtX8FTrfzZqV3nvIDKt3DMYz-e8oTU8jIsxujLt-M,1113
+skillproof/assertions/builtin.py,sha256=hfopqq6YbH7DLURQnW7mtc3wtlpc1w_gGll2URZuS14,5843
+skillproof/assertions/llm_judge.py,sha256=LydykyQOTgDEpvAygOPXzq4-a_sGsPf026rDjglIOMQ,873
+skillproof/judges/__init__.py,sha256=CQSZF0Digtmcw44KWk6gpdhgi0JdniF7_ihgzgls92w,1486
+skillproof/judges/anthropic_judge.py,sha256=72ykOlj5MI5Hh51BODJ1ztOxKx90PLzCGhYdY48zp5c,2043
+skillproof/judges/base.py,sha256=6m3XX_6QNu5_1PEb9EN43WRopBIv0OcznfhyNep6n8k,1684
+skillproof/judges/mock.py,sha256=HBkeyKQEFlBz0L1WQd1hOMwUwsWsk2rzQzeXn9K1y-g,759
+skillproof/judges/openai_judge.py,sha256=sRdOzLVlNjDw95FEDqopwFyjh1pGVKdT0xvEMMxVSMI,1730
+skillproof/parsers/__init__.py,sha256=YAnj1fqja9ZIYNYyUc48E6L5ZPCGka46SioXPxA5Wsc,286
+skillproof/parsers/claude_code.py,sha256=BsXwr9gKsVrEexa4vJNKwTShIepSr0-8sSD4gEzu9vo,5883
+skillproof/parsers/codex.py,sha256=VlFEfGx0vWjzrCKQLPjdm75To7t-lvXL64ZZOdlneE8,4304
+skillproof/report/__init__.py,sha256=V-cDXFzrvhkOfov-UgWxmsWyj1VdGvubs4mVVE1-bck,1233
+skillproof/report/badge.py,sha256=mZX9RqC2m4oBd2IO_hj0PjrgxOk-O6-4Fi4_zTykp5g,1851
+skillproof/report/format.py,sha256=sydrWrCSA4QmoF0UtXXosvnjPkRc-7vGUjeFFIAnc10,2265
+skillproof/report/html_report.py,sha256=9GOQQmuvDd2rbCAN06AxnZI7mPkyeN37p9Y3Ukm-uZE,12371
+skillproof/report/json_report.py,sha256=PapAHbg82tTwzC_qnK9MlYmNcXwTN3eSMc8z5FwqnzA,220
+skillproof/report/markdown.py,sha256=3kSfbC8dCku6Mc29W2m3enibxjcvnLkL7EMIjzZQ4FA,2628
+skillproof/report/summary.py,sha256=gKSSkwOey5bw-tXEk1qeEfx4qLVoJ8YW5ivdmu3aMP8,7224
+skillproof/report/terminal.py,sha256=qBOGijakacLa3HINTi8RlB-yo4-9h1WX_B5kStfHrQ4,3123
+skillproof/runners/__init__.py,sha256=CRLktwUUIHfawUGq28ieB9atJsMmN80vbCWriB7op5s,1096
+skillproof/runners/base.py,sha256=xYmKbraA1UhS4aNdqWZpXklCvMRCLV72wlSfIL8bp6s,3692
+skillproof/runners/claude_code.py,sha256=xrzYPuqb1vH2rKD4arHiiK9Xn16FXjlp98rZVNNppF4,4902
+skillproof/runners/codex.py,sha256=oboDOp4wGEVX4NrxGbeso_YT1lLP4eQjH34Ak3oGLPM,5249
+skillproof/runners/mock.py,sha256=wvA9yfZ6n0zLaxuNzWmZJolytHeq5_1iKvYH2Wp4vBk,3200
+skillproof/runners/openai_compat.py,sha256=KCyHMLTPvr-AR4sBuUlJO5mM6G77CFwKw-XAOyxO2-k,8835
+skillproof-0.1.0.dist-info/METADATA,sha256=qLVnDXE_X_cyozPT6NOTW1c7G1Cfa52EDzkoZE_-QDY,12273
+skillproof-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+skillproof-0.1.0.dist-info/entry_points.txt,sha256=L8Zgf1Nj9c5JBBA2bZ0DbG9nN3uOQ4g5nk2vC-6WR2M,51
+skillproof-0.1.0.dist-info/licenses/LICENSE,sha256=XNNcR1T7eyTKdc3Hw6aXDN0isH9Oj2KacYDhHFfXQ44,1067
+skillproof-0.1.0.dist-info/RECORD,,

skillproof-0.1.0.dist-info/WHEEL

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

skillproof-0.1.0.dist-info/entry_points.txt

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

skillproof-0.1.0.dist-info/licenses/LICENSE

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