smartselect 0.1.3__tar.gz

smartselect-0.1.3/.github/workflows/ci.yml

@@ -0,0 +1,48 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: pip install -e ".[dev]"
+
+      - name: Lint
+        run: ruff check src/ tests/
+
+      - name: Test
+        run: pytest --cov=testwise --cov-report=term-missing
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - run: pip install -e ".[dev]"
+
+      - name: Ruff format check
+        run: ruff format --check src/ tests/
+
+      - name: Type check
+        run: mypy src/testwise/

smartselect-0.1.3/.github/workflows/publish.yml

@@ -0,0 +1,28 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install build tools
+        run: pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

smartselect-0.1.3/.gitignore

@@ -0,0 +1,35 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Testing
+.coverage
+htmlcov/
+.pytest_cache/
+
+# mypy
+.mypy_cache/
+
+# ruff
+.ruff_cache/
+
+# Environment
+.env

smartselect-0.1.3/.testwise.example.yml

@@ -0,0 +1,54 @@
+# Testwise Configuration
+# Copy this file to .testwise.yml in your repo root
+
+runners:
+  # Python/pytest example
+  - name: pytest
+    command: pytest
+    args: ["-v", "--tb=short"]
+    test_patterns: ["tests/**/*.py", "test_*.py", "*_test.py"]
+    parser: pytest           # Use the built-in pytest parser for test-level selection
+    select_mode: test        # "test" for individual test functions, "file" for file-level
+    timeout_seconds: 300
+
+  # JavaScript/Jest example (uncomment to use)
+  # - name: jest
+  #   command: npx jest
+  #   args: ["--verbose"]
+  #   test_patterns: ["**/*.test.ts", "**/*.test.js", "**/*.spec.ts", "**/*.spec.js"]
+  #   parser: generic        # No built-in JS parser yet (file-level selection)
+  #   select_mode: file
+  #   file_arg_style: flag
+  #   file_arg_flag: "--testPathPattern"
+  #   timeout_seconds: 300
+
+  # Go example (uncomment to use)
+  # - name: gotest
+  #   command: go
+  #   args: ["test", "-v"]
+  #   test_patterns: ["**/*_test.go"]
+  #   parser: generic
+  #   select_mode: file
+  #   file_arg_style: none
+  #   timeout_seconds: 300
+
+# LLM configuration
+llm:
+  model: anthropic/claude-sonnet-4-20250514   # Any model supported by litellm
+  api_key_env: ANTHROPIC_API_KEY              # Environment variable containing the API key
+  max_context_tokens: 100000                  # Token budget for context
+  temperature: 0.0                            # Keep deterministic
+  timeout_seconds: 60
+
+# Context assembly
+context:
+  include_test_contents: true    # Send test file contents to LLM (more accurate, more tokens)
+  max_diff_lines: 5000           # Truncate diffs larger than this
+
+# Safety
+fallback_on_error: true    # Run all tests if LLM fails
+run_should_run: true       # Also run "should_run" tests (not just "must_run")
+
+# Optional: filter which files are analyzed
+# include_patterns: ["src/**", "lib/**"]
+# exclude_patterns: ["**/*.md", "docs/**"]

smartselect-0.1.3/CLAUDE.md

@@ -0,0 +1,75 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What is Testwise
+
+Testwise is an LLM-powered test selection tool for CI/CD pipelines. It analyzes git diffs, uses an LLM (via litellm) to classify tests as `must_run`, `should_run`, or `skip`, then executes only the relevant tests. It ships as both a CLI (`testwise`) and a GitHub Actions composite action.
+
+## Development Commands
+
+```bash
+# Install in dev mode
+pip install -e ".[dev]"
+
+# Run all tests
+pytest
+
+# Run tests with coverage
+pytest --cov=testwise --cov-report=term-missing
+
+# Run a single test file
+pytest tests/test_parsers/test_pytest_parser.py
+
+# Run a single test
+pytest tests/test_parsers/test_pytest_parser.py::test_function_name
+
+# Linting
+ruff check src/ tests/
+ruff format src/ tests/
+
+# Type checking
+mypy src/testwise/
+```
+
+## Architecture
+
+The pipeline flows through these stages in order, orchestrated by `cli.py`:
+
+1. **Config** (`config.py`) — Loads `.testwise.yml`, resolves defaults via `TestwiseConfig` Pydantic model
+2. **Diff** (`diff_analyzer.py`) — Extracts git diff between base/head refs, filters and truncates
+3. **Discovery** (`test_discovery.py`) — Finds test files matching runner glob patterns
+4. **Parsing** (`test_discovery.py` → `parsers/`) — Delegates to parser plugins to extract individual test functions with metadata
+5. **Context** (`context_builder.py`) — Assembles diff + parsed tests into LLM messages, respecting token budget
+6. **LLM Selection** (`llm_selector.py`) — Calls LLM via litellm with structured output (falls back to text mode JSON extraction). Returns `LLMSelectionResponse` with per-test classifications
+7. **Execution** (`test_runner.py`) — Runs selected tests using parser's `build_run_command()`
+8. **Reporting** (`reporter.py`) — Outputs results as text, JSON, or GitHub Actions annotations
+
+### Parser Plugin System
+
+Parsers are registered via Python entry points (`testwise.parsers` group) and loaded at runtime by `parsers/__init__.py`. Each parser extends `BaseParser` ABC and implements:
+- `parse_test_file()` — extracts `ParsedTest` objects with names, tags, `@covers` annotations, imports
+- `build_run_command()` — builds the CLI command to run specific tests
+
+Built-in parsers: `pytest` (test-level granularity) and `generic` (file-level fallback).
+
+### Key Models (`models.py`)
+
+All data flows through Pydantic models: `DiffResult` → `ParsedTestFile`/`ParsedTest` → `LLMSelectionResponse`/`TestSelection` → `TestResult` → `RunReport`. The `TestClassification` enum (`must_run`, `should_run`, `skip`) is central to the selection logic.
+
+### LLM Fallback Strategy
+
+`llm_selector.py` has a three-tier approach: (1) structured JSON output via `response_format`, (2) text mode with JSON schema in prompt, (3) raise `LLMError`. The caller in `cli.py` catches `LLMError` and falls back to running all tests when `fallback_on_error: true`.
+
+## Configuration
+
+- Config file: `.testwise.yml` (see `.testwise.example.yml` for all options)
+- Uses litellm model format (e.g., `anthropic/claude-sonnet-4-20250514`, `openai/gpt-4o`)
+- API key is read from the env var specified by `llm.api_key_env`
+
+## Project Setup
+
+- Python >=3.10, build system: hatchling
+- Ruff config: line-length 100, target py310, rules: E, F, I, N, W, UP
+- mypy: strict mode
+- Tests directory: `tests/` with `fixtures/` and `test_parsers/` subdirectories

smartselect-0.1.3/CONTRIBUTING.md

@@ -0,0 +1,130 @@
+# Contributing to Testwise
+
+Thanks for your interest in contributing! Here's how to get started.
+
+## Development Setup
+
+```bash
+git clone https://github.com/mattfrautnick/testwise.git
+cd testwise
+pip install -e ".[dev]"
+```
+
+## Running Tests
+
+```bash
+pytest
+pytest --cov=testwise --cov-report=term-missing
+```
+
+## Linting
+
+```bash
+ruff check src/ tests/
+ruff format src/ tests/
+mypy src/testwise/
+```
+
+## Project Structure
+
+```
+src/testwise/
+  cli.py              # CLI entry point + orchestration
+  models.py           # All Pydantic data models
+  config.py           # Configuration loading
+  diff_analyzer.py    # Git diff extraction
+  test_discovery.py   # Test file discovery
+  context_builder.py  # LLM context assembly
+  llm_selector.py     # LLM interaction
+  test_runner.py      # Test execution
+  reporter.py         # Results formatting
+  parsers/            # Parser plugin system
+    __init__.py       # BaseParser ABC + registry
+    pytest_parser.py  # Python/pytest parser
+    generic_parser.py # File-level fallback
+```
+
+## Writing a Parser Plugin
+
+Parser plugins enable test-level selection for new languages/frameworks.
+
+### 1. Create the Parser
+
+Implement `BaseParser`:
+
+```python
+from testwise.parsers import BaseParser
+from testwise.models import ParsedTest, ParsedTestFile, RunnerConfig
+from pathlib import Path
+
+class MyParser(BaseParser):
+    name = "myframework"
+    languages = ["javascript"]
+    file_patterns = ["*.test.js"]
+
+    def parse_test_file(self, file_path: Path, content: str) -> ParsedTestFile:
+        """Parse a test file and extract individual tests."""
+        tests = []
+        # Your parsing logic here - extract test names, tags, etc.
+        return ParsedTestFile(
+            file_path=str(file_path),
+            language="javascript",
+            tests=tests,
+            imports=[],          # Module imports for dependency mapping
+            fixtures_used=[],    # Shared setup/fixtures
+        )
+
+    def build_run_command(
+        self,
+        tests: list[ParsedTest],
+        runner_config: RunnerConfig,
+        repo_root: Path,
+    ) -> list[str]:
+        """Build CLI command to run specific tests."""
+        cmd = [runner_config.command, *runner_config.args]
+        # Add test selection flags specific to your framework
+        return cmd
+```
+
+### 2. Register via Entry Points
+
+In your package's `pyproject.toml`:
+
+```toml
+[project.entry-points."testwise.parsers"]
+myframework = "my_package.parser:MyParser"
+```
+
+### 3. Test Your Parser
+
+Write tests that verify:
+- Test functions are correctly extracted from sample files
+- Tags/annotations are properly parsed
+- The `build_run_command` produces valid CLI commands
+- Edge cases: empty files, syntax errors, nested classes
+
+### What Makes a Good Parser
+
+- **Extract test names** with qualified paths (file::class::test)
+- **Parse annotations/decorators** into tags and covers lists
+- **Detect parametrized tests** (the LLM uses this info)
+- **Extract imports** (helps the LLM map code dependencies)
+- **Handle errors gracefully** (syntax errors should fall back to file-level)
+
+## Pull Request Guidelines
+
+1. Fork and create a feature branch
+2. Write tests for new functionality
+3. Ensure all tests pass: `pytest`
+4. Ensure linting passes: `ruff check src/ tests/`
+5. Keep commits focused and well-described
+6. Open a PR with a clear description of what and why
+
+## Reporting Issues
+
+Open an issue with:
+- What you expected to happen
+- What actually happened
+- Steps to reproduce
+- Your testwise version (`testwise --version`)
+- Your config file (redact API keys)

smartselect-0.1.3/LICENSE

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

smartselect-0.1.3/PKG-INFO

@@ -0,0 +1,269 @@
+Metadata-Version: 2.4
+Name: smartselect
+Version: 0.1.3
+Summary: LLM-powered test selection for CI/CD pipelines
+Project-URL: Homepage, https://github.com/mattfrautnick/testwise
+Project-URL: Repository, https://github.com/mattfrautnick/testwise
+Project-URL: Issues, https://github.com/mattfrautnick/testwise/issues
+Author: Matthew Frautnick
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,cd,ci,llm,test-selection,testing
+Classifier: Development Status :: 3 - Alpha
+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: click>=8.0
+Requires-Dist: litellm>=1.40.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: tiktoken>=0.7.0
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest-mock; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: types-pyyaml; extra == 'dev'
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <h1 align="center">Testwise</h1>
+  <p align="center">
+    LLM-powered test selection for CI/CD pipelines
+    <br />
+    <em>Run only the tests that matter. Save CI time without sacrificing coverage.</em>
+  </p>
+  <p align="center">
+    <a href="https://github.com/mattfrautnick/testwise/actions/workflows/ci.yml"><img src="https://github.com/mattfrautnick/testwise/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+    <a href="https://pypi.org/project/testwise/"><img src="https://img.shields.io/pypi/v/testwise.svg" alt="PyPI"></a>
+    <a href="https://pypi.org/project/testwise/"><img src="https://img.shields.io/pypi/pyversions/testwise.svg" alt="Python"></a>
+    <a href="https://github.com/mattfrautnick/testwise/blob/main/LICENSE"><img src="https://img.shields.io/github/license/mattfrautnick/testwise" alt="License"></a>
+  </p>
+</p>
+
+---
+
+Testwise analyzes your git diff and uses an LLM to classify every test as `must_run`, `should_run`, or `skip` — then executes only what's needed. It supports **test-level granularity** for languages with parser plugins and falls back to file-level selection for everything else.
+
+## Why Testwise?
+
+Large test suites slow down CI. Most changes only affect a fraction of your tests, but running the full suite every time wastes minutes (or hours). Existing static-analysis approaches miss indirect dependencies and cross-cutting concerns. Testwise uses an LLM that actually understands your code changes and test structure to make smarter decisions — with a safe fallback to run everything if it's ever uncertain.
+
+## How It Works
+
+```
+git diff ─> Discover Tests ─> Parse with Plugins ─> LLM Classifies ─> Run Selected ─> Report
+```
+
+1. **Diff Analysis** — Extracts the git diff between base and head refs
+2. **Test Discovery** — Finds all test files and parses individual test functions via parser plugins
+3. **LLM Classification** — Sends diff + test inventory to an LLM with structured output
+4. **Selective Execution** — Runs only selected tests and reports results with GitHub annotations
+
+## Features
+
+- **Hybrid Granularity** — Test-level selection for languages with parser plugins (pytest built-in), file-level fallback for others
+- **Plugin Architecture** — Extensible parser system via Python entry points. [Write a parser](#writing-a-parser-plugin) for any test framework.
+- **Any LLM Provider** — Uses [litellm](https://github.com/BerriAI/litellm) to support Claude, GPT, Gemini, and 100+ other models
+- **GitHub Actions** — Ships as a composite action with step summary, annotations, and outputs
+- **Safe Fallback** — If the LLM fails or is uncertain, falls back to running all tests
+- **Test Annotations** — Supports `@pytest.mark.covers()` to explicitly map tests to code areas
+
+## Quick Start
+
+### Install
+
+```bash
+pip install smartselect
+```
+
+### Configure
+
+Create `.testwise.yml` in your repo root:
+
+```yaml
+runners:
+  - name: pytest
+    command: pytest
+    args: ["-v", "--tb=short"]
+    test_patterns: ["tests/**/*.py", "test_*.py"]
+    parser: pytest
+    select_mode: test
+
+llm:
+  model: anthropic/claude-sonnet-4-20250514
+  api_key_env: ANTHROPIC_API_KEY
+```
+
+### Run
+
+```bash
+# Dry run — see what the LLM would select
+testwise --dry-run
+
+# Run selected tests
+testwise
+
+# Force all tests (bypass LLM)
+testwise --fallback
+```
+
+### GitHub Actions
+
+```yaml
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # Full history needed for diff
+
+      - uses: mattfrautnick/testwise@v1
+        with:
+          api-key: ${{ secrets.ANTHROPIC_API_KEY }}
+          run-level: should_run
+```
+
+The action writes a Markdown summary to `$GITHUB_STEP_SUMMARY` and emits `::error::` annotations for failing tests inline in your PR diff.
+
+## Test Annotations
+
+Testwise's pytest parser understands standard markers and a custom `@covers` annotation that explicitly maps tests to code areas:
+
+```python
+import pytest
+
+@pytest.mark.covers("auth_module", "user.login")
+def test_login_success(client, db):
+    """Verify successful login flow."""
+    ...
+
+@pytest.mark.integration
+@pytest.mark.covers("payment_service")
+def test_checkout_flow(client):
+    ...
+
+@pytest.mark.parametrize("role", ["admin", "user", "guest"])
+def test_permissions(role):
+    ...
+```
+
+The parser also extracts imports and fixture references automatically — no annotation required for basic dependency mapping.
+
+## Parser Plugins
+
+Testwise uses a plugin architecture for language-specific test parsing. Plugins are registered via Python entry points.
+
+### Built-in Parsers
+
+| Parser | Language | Granularity | Features |
+|--------|----------|-------------|----------|
+| `pytest` | Python | Test-level | Markers, covers, parametrize, fixtures, imports |
+| `generic` | Any | File-level | Fallback for unsupported languages |
+
+### Writing a Parser Plugin
+
+Implement `BaseParser` and register it as an entry point:
+
+```python
+from testwise.parsers import BaseParser
+from testwise.models import ParsedTest, ParsedTestFile, RunnerConfig
+from pathlib import Path
+
+class JestParser(BaseParser):
+    name = "jest"
+    languages = ["javascript", "typescript"]
+    file_patterns = ["*.test.ts", "*.test.js", "*.spec.ts", "*.spec.js"]
+
+    def parse_test_file(self, file_path: Path, content: str) -> ParsedTestFile:
+        # Parse describe/it blocks, extract test names
+        ...
+
+    def build_run_command(self, tests, runner_config, repo_root):
+        # Build jest --testNamePattern command
+        ...
+```
+
+```toml
+# pyproject.toml
+[project.entry-points."testwise.parsers"]
+jest = "my_package.jest_parser:JestParser"
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for a full guide on writing and testing parser plugins.
+
+## CLI Reference
+
+```
+testwise [OPTIONS]
+
+Options:
+  -c, --config PATH                    Path to .testwise.yml
+  -b, --base-ref TEXT                  Base git ref to diff against
+      --head-ref TEXT                  Head git ref (default: HEAD)
+  -o, --output [text|json|github]      Output format (default: text)
+      --output-file PATH               Write JSON report to file
+      --dry-run                        Show selections without running tests
+      --fallback                       Skip LLM, run all tests
+      --run-level [must_run|should_run|all]  Minimum classification to run
+  -v, --verbose                        Verbose logging
+      --version                        Show version
+      --help                           Show this message
+```
+
+## Configuration Reference
+
+See [`.testwise.example.yml`](.testwise.example.yml) for a fully commented example.
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `runners[].name` | string | required | Runner identifier |
+| `runners[].command` | string | required | Test runner command |
+| `runners[].args` | list | `[]` | Additional arguments |
+| `runners[].test_patterns` | list | `[]` | Glob patterns for test files |
+| `runners[].parser` | string | `"generic"` | Parser plugin name |
+| `runners[].select_mode` | string | `"file"` | `"test"` or `"file"` |
+| `runners[].timeout_seconds` | int | `300` | Per-runner timeout |
+| `llm.model` | string | `"anthropic/claude-sonnet-4-20250514"` | LLM model ([litellm format](https://docs.litellm.ai/docs/providers)) |
+| `llm.api_key_env` | string | `"ANTHROPIC_API_KEY"` | Env var containing API key |
+| `llm.max_context_tokens` | int | `100000` | Token budget for context |
+| `llm.temperature` | float | `0.0` | LLM temperature |
+| `fallback_on_error` | bool | `true` | Run all tests if LLM fails |
+| `run_should_run` | bool | `true` | Also run "should_run" tests |
+
+## Roadmap
+
+Testwise is in early development. Here's what's planned:
+
+- [ ] Jest/Vitest parser plugin
+- [ ] Go test parser plugin
+- [ ] Caching layer — skip LLM call for identical diffs
+- [ ] Cost tracking — log token usage and estimated cost per run
+- [ ] Confidence threshold — auto-fallback below a configurable confidence
+- [ ] Test impact analysis — learn from historical runs which tests fail for which changes
+- [ ] GitLab CI integration
+
+Have an idea? [Open an issue](https://github.com/mattfrautnick/testwise/issues) or [start a discussion](https://github.com/mattfrautnick/testwise/discussions).
+
+## Contributing
+
+Contributions are welcome! Whether it's a bug fix, a new parser plugin, or documentation improvements — all contributions help.
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, architecture overview, and the full guide to writing parser plugins.
+
+## Community
+
+- [GitHub Issues](https://github.com/mattfrautnick/testwise/issues) — Bug reports and feature requests
+- [GitHub Discussions](https://github.com/mattfrautnick/testwise/discussions) — Questions, ideas, and show & tell
+
+## License
+
+[MIT](LICENSE)