anki-agent-toolkit 0.1.0__tar.gz

anki_agent_toolkit-0.1.0/.agent/skills/anki-operations/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: anki-operations
+description: Use when working with Anki collections through ankicli or the repo-owned OpenClaw plugin, especially for safe inspection, backend-aware troubleshooting, dry-run-first mutation workflows, or multi-step note/card/tag/deck/media operations.
+---
+
+# Anki Operations
+
+This skill is the workflow layer above `ankicli` and the repo-owned OpenClaw plugin. Use it to choose the right Anki operation, sequence read and write steps safely, and react to backend-specific limits without inventing new behavior.
+
+## Core Rules
+
+1. Read before write. Inspect the collection, search narrowly, and fetch a representative note or card before changing anything.
+2. Prefer `--dry-run` first whenever the command supports it, unless the user clearly wants immediate execution.
+3. Re-verify after mutations with a follow-up read, search, or stats command.
+4. Treat sync and backup as different tools. Sync keeps local and remote state aligned; backup is the rollback path.
+5. Preserve structured `ankicli` errors. Do not reinterpret codes into vague summaries.
+6. Use the narrowest command or tool that solves the task. Do not jump straight to bulk operations.
+7. Respect backend limits. If the active backend reports `BACKEND_OPERATION_UNSUPPORTED`, switch backend or explain the limit.
+
+## Transport Choice
+
+- In OpenClaw, prefer the repo-owned plugin tools first.
+- Outside OpenClaw, prefer `ankicli --json`.
+- Treat both as the same logical surface. The CLI is the source of truth; the plugin is only an adapter.
+
+## Workflow Playbooks
+
+### Inspect And Diagnose
+
+Use this before any meaningful change:
+- identify backend and capabilities
+- resolve the profile when local profile targeting matters
+- inspect auth status if sync or remote state matters
+- inspect backup status when rollback matters
+- inspect collection info or stats
+- use `sync status` before assuming local and remote state match
+- list decks or models if the target is not known
+- use `search count` or `search preview` before wide changes
+- fetch the exact note or card before mutating it
+
+Good command/tool progression:
+- collection or backend info
+- search
+- get
+- mutate
+- verify
+
+### Safe Note Mutation
+
+Use for add, update, patch, tag changes, and note deck moves:
+- resolve the target model, deck, note id, or search query first
+- if the operation supports dry-run, run it first
+- perform the real mutation only after the target is clear
+- read the note again afterward to confirm fields, tags, or deck placement
+
+### Safe Card State Changes
+
+Use for suspend and unsuspend:
+- fetch the card first
+- confirm the deck and note context are the intended target
+- dry-run first when available
+- re-read the card after the change
+
+### Bulk-Safe Changes
+
+Use for import patch, exports, tag cleanup, and larger migrations:
+- count first
+- preview a small sample
+- export or dry-run before committing writes
+- apply the narrowest bulk action possible
+- re-run count or preview after the change
+
+## Backend Strategy
+
+Default preference:
+- use `python-anki` when local collection semantics matter
+- use `ankiconnect` when live desktop integration is the goal
+
+Switch to `python-anki` when you need:
+- local collection validation or lock checks
+- local profile resolution or backup/restore
+- standalone sync/auth
+- deck lifecycle writes
+- tag lifecycle writes
+- media operations
+- any operation not supported by `ankiconnect`
+
+Stay on `ankiconnect` when you need:
+- live desktop-backed reads
+- supported note/card operations through the running app
+
+## Error Handling
+
+- `COLLECTION_REQUIRED`: provide or ask for a collection path when using local collection flows.
+- `BACKEND_UNAVAILABLE`: check installation, running services, or backend selection.
+- `BACKEND_OPERATION_UNSUPPORTED`: switch backend or choose a narrower workflow.
+- `NOTE_NOT_FOUND`, `CARD_NOT_FOUND`, `DECK_NOT_FOUND`, `MODEL_NOT_FOUND`, `TAG_NOT_FOUND`: stop and re-search instead of guessing.
+- `UNSAFE_OPERATION`: retry only when the user clearly intends the real write and the command supports confirmation flags.
+- `COLLECTION_OPEN_FAILED`: treat it as a real backend or fixture limitation, not a harmless warning.
+- `AUTH_REQUIRED`: log in first or confirm stored sync credentials exist.
+- `AUTH_INVALID`: stored sync credentials are stale or bad; log in again.
+- `AUTH_STORAGE_UNAVAILABLE`: stop and fix the host secret-storage environment.
+- `PROFILE_NOT_FOUND` and `PROFILE_RESOLUTION_FAILED`: the local Anki profile selection is wrong or unavailable.
+- `BACKUP_RESTORE_UNSAFE`: do not force restore through an unsafe lock/open-state.
+- `SYNC_CONFLICT`: explicit `sync pull` or `sync push` choice is required; do not guess.
+- `SYNC_IN_PROGRESS` and `SYNC_FAILED`: stop, inspect backend details, and do not stack writes on top of unstable sync state.
+
+## References
+
+Read these only when you need contract detail:
+- Plugin-facing contract: [`docs/openclaw-plugin.md`](/Users/thoffman/ankicli/docs/openclaw-plugin.md)
+- Full CLI surface: [`docs/spec.md`](/Users/thoffman/ankicli/docs/spec.md)
+- Longer workflow version: [`docs/anki-operations-skill.md`](/Users/thoffman/ankicli/docs/anki-operations-skill.md)
+
+## Anti-Patterns
+
+- Do not mutate from a broad search result without fetching the exact target.
+- Do not skip dry-run on risky commands when dry-run exists and the user did not ask to skip it.
+- Do not hide backend-specific unsupported behavior.
+- Do not duplicate the CLI or plugin reference inside this skill.

anki_agent_toolkit-0.1.0/.agent/skills/anki-operations/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Anki Operations"
+  short_description: "Safe Anki workflows via ankicli and OpenClaw."
+  default_prompt: "Use $anki-operations to inspect, diagnose, and safely update an Anki collection with ankicli or its OpenClaw plugin."

anki_agent_toolkit-0.1.0/.agent/skills/release/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: release
+description: Use when preparing, validating, and publishing ankicli releases, especially for GitHub Pages deploys, tagged standalone artifact releases, installer verification, and optional PyPI publishing.
+---
+
+# Release
+
+This skill is the release workflow layer for `ankicli`. Use it when the task involves shipping a new version, validating the public install path, publishing the product site, or checking release automation end to end.
+
+## Core Rules
+
+1. Treat releases as product changes, not just git tags. Validate the site, installers, standalone artifacts, and package path together.
+2. Read before mutate. Inspect the current version, workflow state, and release assets before changing version numbers, tags, or release metadata.
+3. Prefer the standalone artifact path as the primary user install surface. Keep `pipx install ankicli` as fallback documentation, not the hero path.
+4. Verify both public fronts:
+   - GitHub Pages site
+   - GitHub Releases assets
+5. Do not cut a release without checking the installer contract:
+   - raw installer script URLs exist
+   - expected asset names match the release workflow
+   - post-install verification commands still work
+6. Preserve version consistency across Python package metadata, standalone artifact names, and release tags.
+7. Never assume a release succeeded because a tag exists. Check workflow status and actual uploaded assets.
+
+## Release Surfaces
+
+- Product site: GitHub Pages
+- Standalone artifacts: GitHub Releases
+- Raw installer entrypoints:
+  - `scripts/install.sh`
+  - `scripts/install.ps1`
+- Optional package distribution: PyPI/manual publish flow
+
+## Workflow Playbooks
+
+### Pre-Release Validation
+
+Use this before tagging a release:
+- inspect current package version
+- run repo lint
+- run unit, smoke, and distribution coverage relevant to install/release paths
+- build the site
+- build at least one standalone artifact locally when possible
+- extract and execute the built artifact
+- confirm install script URLs and asset naming still align
+
+Good progression:
+- inspect version and git state
+- validate Python/package path
+- validate site build
+- validate installer tests
+- validate standalone artifact build
+- tag only after the above is green
+
+### GitHub Pages Validation
+
+Use when the product site is changing:
+- build the Astro site locally
+- verify landing page install commands
+- verify docs links and install pages
+- confirm the Pages workflow still targets the built static output
+- after push, confirm the live Pages URL renders successfully
+
+### Tagged Release
+
+Use when shipping a real version:
+- bump version in package metadata first
+- commit the version change
+- create and push a tag of the form `vX.Y.Z`
+- confirm the release workflow ran
+- confirm expected artifacts were uploaded:
+  - macOS x64
+  - macOS arm64
+  - Linux x64
+  - Windows x64
+  - checksums file
+- confirm one downloaded artifact runs `ankicli --version` and `ankicli --json doctor backend`
+
+### Installer Verification
+
+Use when installer scripts or release artifact logic changes:
+- verify shell installer path logic
+- verify PowerShell parameter and path logic
+- verify checksum mismatch behavior
+- verify latest-version and explicit-version flows
+- verify install location and PATH instructions are still accurate
+
+### Optional PyPI Publish
+
+Use only when the package distribution path matters:
+- build the wheel/sdist
+- run distribution validation
+- publish manually or via the chosen release process
+- confirm PyPI and standalone release version numbers match
+
+## Versioning Rules
+
+- Package version uses `X.Y.Z`
+- Git tag uses `vX.Y.Z`
+- Release artifacts use `ankicli-X.Y.Z-<target>`
+- Checksums file uses `ankicli-X.Y.Z-checksums.txt`
+
+Do not mix tag-only versions with unchanged package metadata.
+
+## Error Handling
+
+- Missing Pages deployment: inspect the `pages` workflow and built site artifact path.
+- Missing release assets: inspect the `release` workflow matrix and uploaded artifact names.
+- Installer download failure: check tag name, release asset names, and raw script URLs first.
+- Checksum mismatch: treat as a release-blocking issue.
+- Standalone artifact launches but backend probe fails: treat as a packaging/runtime regression, not a docs issue.
+- PyPI publish problems: separate them from GitHub Release problems; they are parallel distribution paths.
+
+## References
+
+Read these when contract detail is needed:
+- Package metadata: [`pyproject.toml`](/Users/thoffman/ankicli/pyproject.toml)
+- CI workflow: [`.github/workflows/ci.yml`](/Users/thoffman/ankicli/.github/workflows/ci.yml)
+- Pages workflow: [`.github/workflows/pages.yml`](/Users/thoffman/ankicli/.github/workflows/pages.yml)
+- Release workflow: [`.github/workflows/release.yml`](/Users/thoffman/ankicli/.github/workflows/release.yml)
+- Product site: [`site/src/pages/index.astro`](/Users/thoffman/ankicli/site/src/pages/index.astro)
+- Installer scripts: [`scripts/install.sh`](/Users/thoffman/ankicli/scripts/install.sh) and [`scripts/install.ps1`](/Users/thoffman/ankicli/scripts/install.ps1)
+
+## Anti-Patterns
+
+- Do not tag first and hope validation passes later.
+- Do not change release asset names in one place without updating installers and docs.
+- Do not publish a release if the standalone artifact path is broken but PyPI still works.
+- Do not treat Pages deployment as optional once the site is the public install front door.
+- Do not overwrite user-facing install commands ad hoc in docs; keep them aligned with the installer contract.

anki_agent_toolkit-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,60 @@
+name: ci
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  fast-path:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: "3.11"
+      - name: Install
+        run: uv sync --extra dev --frozen
+      - name: Ruff
+        run: uv run ruff check .
+      - name: Unit and smoke
+        run: PYTEST_PLUGINS=ankicli.pytest_plugin uv run pytest -c pyproject.toml -m "unit or smoke" --proof-report .artifacts/proof-fast.json
+      - name: Proof matrix audit
+        run: uv run python scripts/audit_quality_matrix.py --proof-report .artifacts/proof-fast.json
+
+  packaging:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    needs: fast-path
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: "3.11"
+      - name: Install
+        run: uv sync --extra dev --frozen
+      - name: Build package
+        run: uv build
+      - name: Distribution validation
+        run: uv run pytest -m distribution
+
+  site:
+    runs-on: ubuntu-latest
+    needs: fast-path
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+          cache-dependency-path: site/package-lock.json
+      - name: Install site deps
+        working-directory: site
+        run: npm ci
+      - name: Build site
+        working-directory: site
+        run: npm run build

anki_agent_toolkit-0.1.0/.github/workflows/pages.yml

@@ -0,0 +1,48 @@
+name: pages
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: pages
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+          cache-dependency-path: site/package-lock.json
+      - name: Install site deps
+        working-directory: site
+        run: npm ci
+      - name: Build site
+        working-directory: site
+        run: npm run build
+      - uses: actions/configure-pages@v5
+        with:
+          enablement: true
+      - uses: actions/upload-pages-artifact@v3
+        with:
+          path: site/dist
+
+  deploy:
+    runs-on: ubuntu-latest
+    needs: build
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - id: deployment
+        uses: actions/deploy-pages@v4

anki_agent_toolkit-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,60 @@
+name: release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: write
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - target: darwin-x64
+            runs-on: macos-15-intel
+          - target: darwin-arm64
+            runs-on: macos-14
+          - target: linux-x64
+            runs-on: ubuntu-latest
+          - target: windows-x64
+            runs-on: windows-latest
+    runs-on: ${{ matrix.runs-on }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: "3.11"
+      - name: Install build deps
+        run: uv sync --extra dev --frozen
+      - name: Build standalone artifact
+        shell: bash
+        run: uv run python scripts/build_release_artifact.py --target ${{ matrix.target }} --version "${GITHUB_REF_NAME#v}"
+      - uses: actions/upload-artifact@v4
+        with:
+          name: release-${{ matrix.target }}
+          path: dist/release/*
+
+  publish:
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
+        with:
+          path: release-artifacts
+          pattern: release-*
+          merge-multiple: true
+      - name: Consolidate checksums
+        run: |
+          mkdir -p release-final
+          find release-artifacts -type f ! -name '*checksums.txt' -exec cp {} release-final/ \;
+          cat release-artifacts/*checksums.txt > release-final/ankicli-${GITHUB_REF_NAME#v}-checksums.txt
+      - name: Create GitHub Release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release create "$GITHUB_REF_NAME" release-final/* --generate-notes --verify-tag

anki_agent_toolkit-0.1.0/.gitignore

@@ -0,0 +1,14 @@
+.venv/
+.pytest_cache/
+.ruff_cache/
+.uv-cache/
+__pycache__/
+*.pyc
+.DS_Store
+dist/
+build/
+.worktrees/
+*.swp
+site/node_modules/
+site/dist/
+site/.astro/

anki_agent_toolkit-0.1.0/AGENTS.md

@@ -0,0 +1,174 @@
+# AGENTS.md
+
+## Product
+
+`ankicli` is a local-first Anki collection management CLI for inspection and mutation. It is not a
+study app and not a TUI.
+
+Supported platforms are macOS, Windows, and Linux. Product-complete support means: the default
+packaged install works, the bundled `python-anki` runtime is usable, `--collection` workflows work,
+`--profile` resolves the platform-default Anki data root, local backup flows work, and auth/sync
+credential storage works.
+
+## Working Rules
+
+- Search first. The repo is small now, but preserve that habit as it grows.
+- Patch minimally. Keep changes tight and avoid broad refactors unless the task requires them.
+- Preserve the JSON output contract. Any shape change must update tests and docs in the same change.
+- Keep backend-specific behavior inside `src/ankicli/backends/`. Do not leak it into CLI or service
+  contracts.
+- Prefer the smallest relevant verification scope before broadening to larger suites.
+- Treat `uv.lock` as mandatory. If dependency resolution changes, update the lockfile in the same
+  change.
+- Do not confuse placeholder command wiring with backend completeness. Expand behavior coverage as
+  commands are implemented.
+
+## Commands
+
+Install:
+
+```bash
+uv sync --extra dev --frozen
+```
+
+Lint:
+
+```bash
+uv run ruff check .
+```
+
+Fast tests:
+
+```bash
+uv run pytest -m "unit or smoke"
+```
+
+Fixture integration:
+
+```bash
+uv run pytest tests/integration/test_python_anki_backend.py
+```
+
+Editable-entrypoint e2e:
+
+```bash
+uv run pytest tests/e2e/test_cli_e2e.py
+```
+
+Distribution validation:
+
+```bash
+uv build
+uv run pytest -m distribution
+```
+
+Real python-anki setup check:
+
+```bash
+export ANKI_SOURCE_PATH=/absolute/path/to/anki
+uv run pytest -m backend_python_anki_real -k anki_source_path_enables_import
+```
+
+Full tests:
+
+```bash
+uv run pytest
+```
+
+Single file:
+
+```bash
+uv run pytest tests/unit/test_output.py
+```
+
+Build package:
+
+```bash
+uv build
+```
+
+## Test Tiers
+
+- `unit`: logic, parsing, safety checks, output shapes, error mapping
+- `smoke`: fastest CLI checks for local loops and CI
+- `fixture_integration`: deterministic SQLite fixture and contract-level command coverage
+- `e2e`: editable-install CLI entrypoint checks through `uv run`
+- `distribution`: built artifact install and entrypoint validation in an isolated environment
+- `backend_python_anki_real`: opt-in local source setup checks and future true `import anki`
+  integration coverage
+
+Preferred loops:
+
+```bash
+uv run pytest -m "unit or smoke"
+uv run pytest tests/integration/test_python_anki_backend.py
+uv run pytest tests/e2e/test_cli_e2e.py
+uv build && uv run pytest -m distribution
+export ANKI_SOURCE_PATH=/absolute/path/to/anki && uv run pytest -m backend_python_anki_real -k anki_source_path_enables_import
+uv run python scripts/prepare_real_backend.py --reset
+uv run python scripts/prepare_ankiconnect_backend.py
+```
+
+## Safety
+
+- Destructive commands must stay explicit and gated by `--yes` or `--force`.
+- Do not casually mutate shared fixtures. Clone or generate per test when write isolation matters.
+- Diagnostics should succeed as diagnostics even when the environment is incomplete. Report state;
+  do not hide it behind generic crashes.
+- E2E should exercise the editable installed CLI entrypoint, not `python -m ...` shortcuts.
+- Distribution validation should cover built artifacts separately from editable-entrypoint e2e.
+- `ANKI_SOURCE_PATH` is the only supported local source override for real `python-anki` work.
+- A raw upstream checkout currently proves import-path setup only unless that checkout has already
+  generated the required Python build artifacts.
+
+## Fixture Policy
+
+- Keep at least one small canonical fixture collection for fast tests.
+- Prefer deterministic fixture setup over ad hoc local state.
+- The default fixture is repo-owned and generated by `tests/fixtures/build_fixture.py`.
+- That default fixture is a contract fixture, not yet a true Anki collection fixture.
+- If a fixture format changes, update the generator and document the change in
+  `tests/fixtures/README.md`.
+- Real backend work should use a separate local Anki source checkout, not mutate the contract
+  fixture assumptions.
+- For true collection-level validation, prefer an installed official `anki` wheel or a built
+  upstream checkout over an unbuilt raw source tree.
+
+## Confidence Model
+
+- Do not describe `fixture_integration` as proof of real Anki behavior.
+- Keep `fixture_integration` resilient in mixed local environments, including when an official
+  `anki` wheel is installed for real-backend work.
+- Do not describe `e2e` as proof that built wheels or sdists install correctly.
+- Reserve “real backend integration” for tests that actually open collections through `import anki`.
+- Treat `backend_python_anki_real` as opt-in and local unless CI is explicitly expanded later.
+
+## Release And Packaging
+
+- `uv build` must succeed before calling the package shape stable.
+- `uv` is the workflow frontend; `hatchling` is the build backend configured in `pyproject.toml`.
+- Packaging regressions should be caught by the `distribution` suite or dedicated build checks, not
+  discovered manually.
+
+## Real Anki Source Setup
+
+- Use a sibling checkout of upstream [ankitects/anki](https://github.com/ankitects/anki).
+- Pin local setup docs to tag `25.09.2` until deliberately updated.
+- Set `ANKI_SOURCE_PATH` to that checkout root.
+- Import-path verification:
+
+```bash
+UV_CACHE_DIR=.uv-cache uv run python -c "from ankicli.runtime import configure_anki_source_path; import importlib.util; configure_anki_source_path(); print(importlib.util.find_spec('anki') is not None)"
+```
+
+- For real `Collection`-level validation, use one of:
+  - official `anki==25.9.2` installed into the project environment, or
+  - an upstream checkout that has been built far enough to provide generated Python artifacts
+- A raw upstream source checkout may fail at `Collection` import/use time due to missing generated
+  modules such as protobuf outputs.
+- Set `ANKICLI_REAL_COLLECTION` only when you want the real-backend suite to run `collection info`
+  against an actual collection.
+- Use `uv run python scripts/prepare_real_backend.py --reset` to automate the wheel-backed local
+  validation path and emit the required env vars.
+- Use `uv run python scripts/prepare_ankiconnect_backend.py` to probe a live AnkiConnect instance
+  and emit the env vars for `backend_ankiconnect_real`.

anki_agent_toolkit-0.1.0/LICENSE

@@ -0,0 +1,17 @@
+GNU AFFERO GENERAL PUBLIC LICENSE
+Version 3, 19 November 2007
+
+SPDX-License-Identifier: AGPL-3.0-or-later
+
+Copyright (C) 2026 ankicli contributors
+
+This repository is licensed under the GNU Affero General Public License,
+version 3 or, at your option, any later version.
+
+`ankicli` depends on and distributes the upstream Anki runtime, which is
+licensed under the GNU Affero General Public License, version 3 or later.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see:
+
+https://www.gnu.org/licenses/agpl-3.0.txt

anki_agent_toolkit-0.1.0/Makefile

@@ -0,0 +1,48 @@
+.PHONY: lint build test-fast test-unit test-smoke test-fixture-integration test-e2e test-distribution test-all test-backup-real test-matrix test-matrix-phase3 real-backend-setup ankiconnect-backend-setup
+
+PROOF_REPORT ?= /tmp/ankicli-proof-report.json
+MATRIX_AUDIT_ARGS ?= --proof-report $(PROOF_REPORT)
+
+lint:
+	UV_CACHE_DIR=.uv-cache uv run ruff check .
+
+build:
+	UV_CACHE_DIR=.uv-cache uv build
+
+test-fast:
+	PYTEST_PLUGINS=ankicli.pytest_plugin UV_CACHE_DIR=.uv-cache uv run pytest -c pyproject.toml -m "unit or smoke" --proof-report $(PROOF_REPORT)
+
+test-unit:
+	UV_CACHE_DIR=.uv-cache uv run pytest -m unit
+
+test-smoke:
+	UV_CACHE_DIR=.uv-cache uv run pytest -m smoke
+
+test-fixture-integration:
+	UV_CACHE_DIR=.uv-cache uv run pytest tests/integration/test_python_anki_backend.py
+
+test-e2e:
+	UV_CACHE_DIR=.uv-cache uv run pytest tests/e2e/test_cli_e2e.py
+
+test-distribution:
+	UV_CACHE_DIR=.uv-cache uv build
+	UV_CACHE_DIR=.uv-cache uv run pytest -m distribution
+
+test-all:
+	UV_CACHE_DIR=.uv-cache uv run pytest
+
+test-backup-real:
+	UV_CACHE_DIR=.uv-cache uv run pytest -m backend_python_anki_backup_real
+
+test-matrix:
+	PYTEST_PLUGINS=ankicli.pytest_plugin UV_CACHE_DIR=.uv-cache uv run pytest -c pyproject.toml -m "unit or smoke" --proof-report $(PROOF_REPORT)
+	UV_CACHE_DIR=.uv-cache uv run python scripts/audit_quality_matrix.py $(MATRIX_AUDIT_ARGS)
+
+test-matrix-phase3:
+	UV_CACHE_DIR=.uv-cache uv run python scripts/run_matrix_phase3.py
+
+real-backend-setup:
+	UV_CACHE_DIR=.uv-cache uv run python scripts/prepare_real_backend.py
+
+ankiconnect-backend-setup:
+	UV_CACHE_DIR=.uv-cache uv run python scripts/prepare_ankiconnect_backend.py