sluicer 0.2.0__tar.gz

sluicer-0.2.0/.claude-plugin/marketplace.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
+  "name": "sluicer",
+  "description": "Deterministic web extraction for agents: the data a page declares, with provenance, and no model in the loop.",
+  "owner": { "name": "Nichita Briculschi", "url": "https://github.com/Gi0tto" },
+  "plugins": [
+    {
+      "name": "sluicer",
+      "description": "Read what a page declares about itself, in eight vocabularies at once, and get back records where every field names the vocabulary it came from. Fetches only as expensively as it must, announces itself by name, and obeys robots.txt. Needs uv on the PATH: the MCP server runs from the plugin's own copy through uvx.",
+      "source": "./",
+      "category": "productivity",
+      "homepage": "https://github.com/Gi0tto/sluicer"
+    }
+  ]
+}

sluicer-0.2.0/.claude-plugin/mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "sluicer": {
+      "command": "uvx",
+      "args": ["--from", "${CLAUDE_PLUGIN_ROOT}[mcp]", "sluicer-mcp"]
+    }
+  }
+}

sluicer-0.2.0/.claude-plugin/plugin.json

@@ -0,0 +1,22 @@
+{
+  "name": "sluicer",
+  "version": "0.2.0",
+  "description": "Read the structured data a web page already declares, with the provenance of every field, and no model in the loop. Fetches at the lowest price that works, announces itself, and obeys robots.txt. Learns extractors that fail loudly when a site changes layout, and heals them. Ships an MCP server with six tools and a skill that says when to use them.",
+  "author": { "name": "Nichita Briculschi", "url": "https://github.com/Gi0tto" },
+  "license": "MIT",
+  "homepage": "https://github.com/Gi0tto/sluicer",
+  "repository": "https://github.com/Gi0tto/sluicer",
+  "keywords": [
+    "scraping",
+    "structured-data",
+    "json-ld",
+    "microdata",
+    "opengraph",
+    "schema-org",
+    "extraction",
+    "markdown",
+    "robots-txt",
+    "deterministic"
+  ],
+  "mcpServers": "./.claude-plugin/mcp.json"
+}

sluicer-0.2.0/.dockerignore

@@ -0,0 +1,10 @@
+# Everything is left out, and only what the image is built from comes back in.
+# A list of exclusions forgets the next cache directory; a list of inclusions
+# cannot send a .venv, a .git or a site/ it never named.
+*
+!pyproject.toml
+!README.md
+!LICENSE
+!src/
+**/__pycache__
+**/*.pyc

sluicer-0.2.0/.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,44 @@
+name: Something read wrong
+description: A page that Sluicer got wrong, or would not read at all
+labels: [bug]
+body:
+  - type: input
+    id: page
+    attributes:
+      label: The page
+      description: A URL. If it is not public, attach the HTML below instead. Without the page this is a guess.
+      placeholder: https://example.com/product
+  - type: textarea
+    id: returned
+    attributes:
+      label: What Sluicer returned
+      description: The output of `sluicer extract <page>`.
+      render: json
+    validations:
+      required: true
+  - type: textarea
+    id: declared
+    attributes:
+      label: What the page actually declares
+      description: The field, the value, and where in the source it lives.
+    validations:
+      required: true
+  - type: dropdown
+    id: kind
+    attributes:
+      label: Which is it?
+      description: A missing value is a known cost we accept in places; a wrong one is the kind of bug this project takes most seriously.
+      options:
+        - A value came back wrong
+        - A value did not come back at all
+        - The call failed or crashed
+    validations:
+      required: true
+  - type: textarea
+    id: versions
+    attributes:
+      label: Versions
+      description: "`sluicer --version`, your Python version, and which extras are installed."
+      render: text
+    validations:
+      required: true

sluicer-0.2.0/.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: A security vulnerability
+    url: https://github.com/Gi0tto/sluicer/security/advisories/new
+    about: Report it privately, never in a public issue. SECURITY.md says what happens next.

sluicer-0.2.0/.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,38 @@
+name: Something missing
+description: A capability Sluicer should have
+labels: [enhancement]
+body:
+  - type: textarea
+    id: task
+    attributes:
+      label: What you were trying to do
+      description: The task, not the feature. The feature is your solution, and there may be a cheaper one.
+    validations:
+      required: true
+  - type: textarea
+    id: instead
+    attributes:
+      label: What you did instead
+  - type: dropdown
+    id: model
+    attributes:
+      label: Does it need an LLM or a paid API?
+      description: If it does, this project will say no, and it is better to know now. The constraint is deliberate and documented in CONTRIBUTING.md.
+      options:
+        - "No"
+        - "Yes"
+        - Not sure
+    validations:
+      required: true
+  - type: checkboxes
+    id: limits
+    attributes:
+      label: Known limits
+      description: docs/known-limits.md lists what we know we do not do yet. If your case is there, say below why it matters to you; that is how things get prioritised.
+      options:
+        - label: I checked docs/known-limits.md
+          required: true
+  - type: textarea
+    id: why
+    attributes:
+      label: Why it matters to you

sluicer-0.2.0/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,15 @@
+**What changes, in one sentence.**
+
+**The test that proves it.** Name it. It should fail without your change; say
+that you watched it fail, and for which reason.
+
+**Measured, not assumed.** If you claim it is faster, more accurate or reads
+more pages, say by how much and against what.
+
+**Checklist**
+
+- [ ] `uv run pytest` passes from the repository root
+- [ ] No network access in any test
+- [ ] No LLM call and no paid API anywhere in the path
+- [ ] Annotations are honest: nothing typed `object` that has a known type
+- [ ] English in code, comments, tests and commit messages

sluicer-0.2.0/.github/dependabot.yml

@@ -0,0 +1,12 @@
+version: 2
+updates:
+  # "uv" reads uv.lock; "pip" does not, and would leave the lock behind.
+  - package-ecosystem: "uv"
+    directory: "/"
+    schedule:
+      interval: "monthly"
+    open-pull-requests-limit: 5
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "monthly"

sluicer-0.2.0/.github/workflows/ci.yml

@@ -0,0 +1,312 @@
+name: CI
+
+on:
+  workflow_dispatch:
+  schedule:
+    # Once a week against whatever the extras resolve to today. A >=2 pin does not
+    # stop a 3.0 landing with another rename, and that would otherwise be found by
+    # a user rather than by us.
+    - cron: "0 6 * * 1"
+  push:
+    branches: [main]
+    paths-ignore: ["**/*.md", "docs/**"]
+  pull_request:
+    branches: [main]
+    paths-ignore: ["**/*.md", "docs/**"]
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  tests:
+    name: Tests on Python ${{ matrix.python }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v10.2.0
+        with:
+          enable-cache: true
+      - name: Run the suite
+        run: uv run --python ${{ matrix.python }} pytest -q
+
+  quality:
+    # Separate from the matrix above on purpose: a red cross here names which
+    # gate refused the commit, and each step names which of the three it was.
+    # Four human review passes were the only thing standing between a defect
+    # and this repository, and a wrong type annotation still got past one.
+    name: Lint, types and coverage
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v10.2.0
+        with:
+          enable-cache: true
+      - name: Lint
+        run: uv run --python 3.13 ruff check src tests
+      - name: Types
+        # Reads its own settings from pyproject: strict, against src, at the
+        # 3.10 floor this package declares whatever interpreter is running it.
+        run: uv run --python 3.13 mypy
+      - name: Coverage
+        # One interpreter, so the floor is measured against the same thing
+        # every time. The matrix above is what proves the suite passes on all
+        # four versions.
+        run: uv run --python 3.13 pytest -q --cov --cov-report=term-missing
+
+  offline:
+    name: The suite opens no socket
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v10.2.0
+      - name: Run the suite with the network taken away
+        run: |
+          cat > /tmp/no_network.py <<'PY'
+          """Fail the build if any test tries to reach the network.
+
+          The project's first promise is that a run costs CPU and nothing else,
+          and a promise nothing enforces is a wish.
+
+          This blocks connecting, not the socket type itself. Replacing
+          socket.socket wholesale looks stricter and is simply wrong: the stdlib
+          ssl module does `class SSLSocket(socket)`, so anything importing it
+          dies with a TypeError that has nothing to do with the network. Ask
+          what a test is forbidden to DO, not what it may name.
+          """
+          import socket
+          import sys
+
+
+          class Blocked(RuntimeError):
+              pass
+
+
+          def refuse(*args, **kwargs):
+              raise Blocked(
+                  "a test tried to reach the network; the suite must never do that"
+              )
+
+
+          socket.socket.connect = refuse
+          socket.socket.connect_ex = refuse
+          socket.create_connection = refuse
+          socket.getaddrinfo = refuse
+
+          import pytest
+
+          sys.exit(pytest.main(["-q"]))
+          PY
+          uv run python /tmp/no_network.py
+
+  build:
+    name: The package builds and its metadata parses
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v10.2.0
+      - name: Build the wheel and the sdist
+        run: uv build
+      - name: Check the metadata
+        run: uvx twine check dist/*
+
+  import-without-extras:
+    name: Importing works without any extra
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v10.2.0
+      - name: Install the base package only, then import it
+        run: |
+          uv venv
+          uv pip install .
+          # `.venv/bin/python`, not `uv run`, in this job and the two below:
+          # `uv run` re-syncs the environment to uv.lock and installs the source
+          # tree in its place, so the check would run against the dev
+          # environment rather than the install it names -- the trap the
+          # floors job documents.
+          .venv/bin/python -c "
+          import importlib.util, sluicer
+          for extra in ('scrapling', 'trafilatura', 'mcp'):
+              assert importlib.util.find_spec(extra) is None, extra + ' leaked into the base install'
+          print('base install imports cleanly, version', sluicer.__version__)
+          "
+
+  with-extras:
+    name: The extras install and the code can actually use them
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v10.2.0
+      - name: Install every extra
+        run: |
+          uv venv
+          uv pip install '.[fetch,markdown,mcp]'
+      - name: Use each one against the package that was really installed
+        run: |
+          .venv/bin/python -c "
+          # The suite fakes these libraries, and a fake can only confirm the shape
+          # you already believe in. This job is the only place that finds out what
+          # the published package actually ships. It caught the mcp 2.x rename.
+          from sluicer.markdown import to_markdown
+          page = '<html><head><meta charset=\"windows-1252\"></head><body><article><h1>Caf\xe9</h1><p>' + ('Real sentences. ' * 30) + '</p></article></body></html>'
+          out = to_markdown(page.encode('windows-1252'))
+          assert 'Caf\xe9' in out, 'the markdown path lost the accent: ' + out[:80]
+          print('markdown: accent survived')
+
+          # protego parses robots.txt and arrives with scrapling[fetchers]. The unit
+          # tests fake it, and a fake agrees with whatever you wrote it to agree with,
+          # so the real semantics are only ever checked here.
+          from sluicer.fetch.identity import USER_AGENT, robots_allows
+          assert 'Sluicer' in USER_AGENT and 'github.com' in USER_AGENT, USER_AGENT
+          refuse = 'User-agent: Sluicer\nDisallow: /private/\n\nUser-agent: *\nAllow: /\n'
+          assert robots_allows('https://example.com/private/p', read=lambda u: refuse, cache={}) is False
+          assert robots_allows('https://example.com/public', read=lambda u: refuse, cache={}) is True
+          assert robots_allows('https://example.com/p', read=lambda u: None, cache={}) is True
+          print('robots: the real parser agrees with what the suite believes')
+
+          from sluicer.fetch.scrapling_rungs import default_rungs
+          names = [name for name, _ in default_rungs()]
+          assert names[:2] == ['http', 'browser'], names
+          print('fetch: three rungs built against the real scrapling')
+
+          import asyncio
+          from sluicer.mcp_server import build_server
+          server = build_server()
+          tools = sorted(t.name for t in asyncio.run(server.list_tools()))
+          assert tools == ['compile_extractor', 'extract_declared', 'fetch_page', 'heal_extractor', 'page_markdown', 'run_extractor'], tools
+
+          # Registration is not use. The SDK's dispatch is where a future release
+          # can break us while every import still resolves, so call a tool for real.
+          page = '<html><head><script type=\"application/ld+json\">{\"@type\":\"Product\",\"name\":\"Brake pad set\"}</script></head><body></body></html>'
+          answer = asyncio.run(server.call_tool('extract_declared', {'html_or_url': page}))
+          text = str(answer)
+          assert 'Brake pad set' in text, 'the SDK dispatch lost the record: ' + text[:200]
+          assert 'jsonld' in text, 'the provenance did not survive dispatch: ' + text[:200]
+
+          markdown_answer = asyncio.run(server.call_tool('page_markdown', {'html_or_url': '<html><body><article><h1>Title</h1><p>' + ('Real sentences. ' * 30) + '</p></article></body></html>'}))
+          assert 'Title' in str(markdown_answer), str(markdown_answer)[:200]
+          print('mcp: three tools listed, and two of them answered through the SDK dispatch')
+          "
+
+  floors:
+    name: The declared minimum versions actually work
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v10.2.0
+      # A dependency floor nobody installs is a wish, not a constraint. Both
+      # base floors were wrong when this job was written: lxml 5.0 ships no
+      # wheel for cp313 and none at all for macOS arm64, and click 8.1.8 fails
+      # fourteen tests because its CliRunner does not capture stderr
+      # separately. Both had been declared for months and never executed.
+      #
+      # Pinned to the minimum Python this project claims: on a newer
+      # interpreter the resolver climbs above the floor, because the floor
+      # version has no wheel for it, and the job would pass without ever
+      # installing what it exists to test.
+      #
+      # The base is resolved on its own. Installing the extras alongside it
+      # lifts lxml and click above their floors, because the extras depend on
+      # them too.
+      #
+      # `.venv/bin/python` throughout, never `uv run`: `uv run` re-syncs the
+      # environment from pyproject.toml and reinstalls lxml at its newest,
+      # which silently undoes the pin. The assertion below caught exactly that
+      # on this job's first run, which is why it is an assertion and not a
+      # printed list somebody skims.
+      - name: Install the base at its declared floors
+        run: |
+          uv venv --python 3.10
+          uv pip install --resolution lowest-direct .
+          uv pip install pytest
+      - name: Check those really are the floors, not something above them
+        run: |
+          .venv/bin/python -c "
+          import importlib.metadata as md
+          for name, floor in {'lxml': '5.3', 'click': '8.2'}.items():
+              got = md.version(name)
+              assert got.startswith(floor), (
+                  name + ' resolved to ' + got + ', not the declared floor '
+                  + floor + ': this job is not testing what it claims to test'
+              )
+              print(name, got, '-- the declared floor')
+          "
+      - name: Run the suite against them
+        run: .venv/bin/python -m pytest -q
+      - name: And again with every extra at its own lowest version
+        run: |
+          uv pip install --resolution lowest-direct '.[fetch,markdown,mcp,microformats]'
+          uv pip list
+          .venv/bin/python -m pytest -q
+
+  latest-extras:
+    name: The extras still work at their newest versions
+    runs-on: ubuntu-latest
+    if: github.event_name == 'schedule' || github.event_name == 'workflow_dispatch'
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v10.2.0
+      - name: Install the extras unpinned and use them
+        run: |
+          uv venv
+          uv pip install '.[fetch,markdown,mcp]' --upgrade
+          .venv/bin/python -c "
+          import asyncio, importlib.metadata as md
+          for name in ('scrapling', 'trafilatura', 'mcp'):
+              print(name, md.version(name))
+          from sluicer.mcp_server import build_server
+          server = build_server()
+          tools = sorted(t.name for t in asyncio.run(server.list_tools()))
+          assert tools == ['compile_extractor', 'extract_declared', 'fetch_page', 'heal_extractor', 'page_markdown', 'run_extractor'], tools
+          print('still building against the newest published extras')
+          "
+
+  docker:
+    name: The image builds, runs unprivileged, and reads a page
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - name: Build the image
+        run: docker build -t sluicer:ci .
+      - name: Use it
+        # A page handed to it needs no network, so this proves the install in
+        # the image without depending on any site being up.
+        run: |
+          uid=$(docker run --rm sluicer:ci id -u)
+          test "$uid" != 0 || { echo "the image runs as root"; exit 1; }
+          printf '%s' '<script type="application/ld+json">{"@type":"Product","name":"Pad"}</script>' > page.html
+          docker run --rm -v "$PWD/page.html:/tmp/page.html:ro" sluicer:ci \
+            sluicer extract /tmp/page.html | tee out.json
+          grep -q '"Pad"' out.json
+
+  docker-browser:
+    # The browser variant is most of a gigabyte and minutes to build, so it is
+    # proven weekly rather than on every push -- but proven, because a build
+    # argument nobody builds is a claim in a comment.
+    name: The image builds with its browser
+    runs-on: ubuntu-latest
+    if: github.event_name == 'schedule' || github.event_name == 'workflow_dispatch'
+    steps:
+      - uses: actions/checkout@v7
+      - name: Build the image with Chromium
+        run: docker build --build-arg WITH_BROWSER=1 -t sluicer:browser .
+      - name: The unprivileged user can launch the browser
+        run: |
+          docker run --rm sluicer:browser python -c "
+          from playwright.sync_api import sync_playwright
+          with sync_playwright() as p:
+              browser = p.chromium.launch()
+              page = browser.new_page()
+              page.set_content('<p>ok</p>')
+              assert page.inner_text('p') == 'ok'
+              browser.close()
+          print('chromium launches as', __import__('os').getuid())
+          "

sluicer-0.2.0/.github/workflows/docs.yml

@@ -0,0 +1,53 @@
+name: Docs
+
+on:
+  push:
+    branches: [main]
+    paths: ["docs/**", "mkdocs.yml", "README.md", "ROADMAP.md"]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: pages
+  cancel-in-progress: false
+
+jobs:
+  # Two jobs rather than one, because they answer different questions. Building
+  # is a test: --strict fails on a broken link or a page nothing references, and
+  # it has to run on every push whatever the repository's visibility. Deploying
+  # is a publication, and GitHub Pages is unavailable on a private repository
+  # outside a paid plan -- so gating the build on that would mean a broken doc
+  # could land unnoticed while the repository is private, which is exactly when
+  # the docs are being written.
+  build:
+    name: The documentation builds
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v10.2.0
+      - name: Build the site
+        # Pinned below 2 on both: MkDocs 2.0 is announced as a breaking release
+        # and mkdocs-material already warns about it, so an unpinned uvx would
+        # change what --strict means on the day it lands, not on a day we chose.
+        run: uvx --from 'mkdocs>=1.6,<2' --with 'mkdocs-material>=9.7,<10' mkdocs build --strict
+      - uses: actions/upload-pages-artifact@v5
+        with:
+          path: site
+
+  deploy:
+    name: The documentation is published
+    needs: build
+    # Pages refuses a private repository on the free plan with a 404 that reads
+    # like a missing artifact. Skipping is the honest report: nothing is wrong.
+    if: github.event.repository.visibility == 'public'
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - id: deployment
+        uses: actions/deploy-pages@v5

sluicer-0.2.0/.github/workflows/release.yml

@@ -0,0 +1,86 @@
+name: Release
+
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+
+# Nothing here writes to the repository. The one elevated permission is the
+# OIDC token trusted publishing needs, and only the job that publishes gets it.
+permissions:
+  contents: read
+
+jobs:
+  build:
+    name: Build and check the distributions
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v10.2.0
+      - name: The tag and the version must agree
+        if: startsWith(github.ref, 'refs/tags/v')
+        run: |
+          uv run python -c "
+          import os, tomllib, pathlib
+          declared = tomllib.loads(pathlib.Path('pyproject.toml').read_text())['project']['version']
+          tagged = os.environ['GITHUB_REF_NAME'].removeprefix('v')
+          assert declared == tagged, f'pyproject says {declared}, the tag says {tagged}'
+          print('version agrees:', declared)
+          "
+      - name: The suite must pass before anything is published
+        run: uv run --python 3.13 pytest -q
+      - run: uv build
+      - name: Check the metadata the way PyPI will
+        run: uvx twine check dist/*
+      - uses: actions/upload-artifact@v7
+        with:
+          name: distributions
+          path: dist/
+
+  installs:
+    name: The built wheel installs and works on its own
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      # No checkout: the wheel has to stand on its own, and a source tree in the
+      # working directory is what an import would quietly find instead of it.
+      - uses: actions/download-artifact@v8
+        with:
+          name: distributions
+          path: dist/
+      - uses: astral-sh/setup-uv@v10.2.0
+      - name: Install the wheel in a clean environment and use it
+        run: |
+          uv venv --python 3.13
+          uv pip install dist/*.whl
+          .venv/bin/python -c "
+          import sluicer
+          page = '<script type=\"application/ld+json\">{\"@type\":\"Product\",\"name\":\"Pad\"}</script>'
+          result = sluicer.extract(page)
+          assert result.records and result.records[0].type == 'Product', result
+          assert sluicer.__file__.startswith('$PWD/.venv/'), sluicer.__file__
+          print('wheel', sluicer.__version__, 'installs, imports and extracts')
+          "
+          .venv/bin/sluicer --version
+
+  publish:
+    name: Publish to PyPI
+    needs: [build, installs]
+    runs-on: ubuntu-latest
+    # Off until the PyPI side exists: a trusted publisher for this repository
+    # and workflow, registered at pypi.org, and the repository variable
+    # PUBLISH_TO_PYPI set to true. Until then a tag builds and checks the
+    # distributions and stops here, instead of failing on a missing publisher.
+    if: startsWith(github.ref, 'refs/tags/v') && vars.PUBLISH_TO_PYPI == 'true'
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          name: distributions
+          path: dist/
+      # Trusted publishing: PyPI verifies this workflow's identity, so no API
+      # token is stored anywhere. Configure it once at
+      # https://pypi.org/manage/project/sluicer/settings/publishing/
+      - uses: pypa/gh-action-pypi-publish@release/v1

sluicer-0.2.0/.gitignore

@@ -0,0 +1,18 @@
+__pycache__/
+*.pyc
+.venv/
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.coverage
+htmlcov/
+bench/cache/
+.DS_Store
+.superpowers/
+stdout.txt
+stderr.txt
+exitcode.txt
+site/