rce-path 0.1.0__tar.gz

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

@@ -0,0 +1,29 @@
+name: Test and build
+on:
+  push:
+    branches: ['**']
+  pull_request:
+permissions:
+  contents: read
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.13'
+      - run: python -m pip install -e ".[dev]"
+      - run: python -m pytest -q
+      - run: python -m ruff check src tests scripts
+      - run: python -m mypy
+      - run: python -m build
+      - run: python -m twine check dist/*
+      - name: Install and smoke-test wheel
+        run: |
+          python -c "import glob,subprocess,sys; subprocess.check_call([sys.executable,'-m','pip','install','--force-reinstall','--no-deps',glob.glob('dist/*.whl')[0]])"
+          python scripts/check_install.py
+      - uses: actions/upload-artifact@v4
+        with:
+          name: distributions
+          path: dist/*

rce_path-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,49 @@
+name: Publish to PyPI
+on:
+  push:
+    tags: ['rce-path-v*']
+  workflow_dispatch:
+permissions:
+  contents: read
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.13'
+      - name: Verify release version
+        if: github.event_name == 'push'
+        run: |
+          python - <<'PY'
+          import os, tomllib
+          version = tomllib.load(open('pyproject.toml', 'rb'))['project']['version']
+          assert os.environ['GITHUB_REF_NAME'] == f'rce-path-v{version}', 'Tag/version mismatch'
+          PY
+      - run: python -m pip install -e ".[dev]"
+      - run: python -m pytest -q
+      - run: python -m ruff check src tests scripts
+      - run: python -m mypy
+      - run: python -m build
+      - run: python -m twine check dist/*
+      - name: Install and smoke-test wheel
+        run: |
+          python -c "import glob,subprocess,sys; subprocess.check_call([sys.executable,'-m','pip','install','--force-reinstall','--no-deps',glob.glob('dist/*.whl')[0]])"
+          python scripts/check_install.py
+      - uses: actions/upload-artifact@v4
+        with:
+          name: distributions
+          path: dist/*
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: distributions
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

rce_path-0.1.0/.gitignore

@@ -0,0 +1,15 @@
+__pycache__/
+*.py[cod]
+.venv/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+dist/
+build/
+*.egg-info/
+.coverage
+htmlcov/
+.rce-path-cache/
+.test-runs/
+.smoke-venv/
+.validation-ci/

rce_path-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,23 @@
+# Contributing
+
+Install `python -m pip install -e ".[dev]"`. Keep the static scanner independent
+of optional AI SDKs. Run pytest, Ruff, mypy, build, and Twine before release.
+
+`src/rce_path` follows the spec's pipeline: ingestion, symbols, CFG, flow, rules,
+findings, optional `llm/providers`, reports, and CLI. Models are versioned at the
+evidence boundary. Add future cross-function summaries at the flow boundary,
+provider roles at the review contract, and SARIF at the report boundary. Validation
+must be a separate Phase 3 component; do not execute targets to improve static
+coverage. No repository-provided executable plugins are accepted.
+
+Labeled synthetic fixtures live in `tests/fixtures/phase1.json`. Each records a
+unique ID, source, expected category/negative control, and relevant diagnostics.
+They are development/release fixtures, not independent holdout benchmarks. Keep
+future project datasets split by project and record provenance, revisions, and
+vulnerable/patched labels before tuning. No detection superiority claim follows
+from this fixture suite.
+
+Provider tests use identical scenarios for both adapters, fake transports, no
+credentials, no model downloads, and no network. Optional live tests are manual
+and use the operator's selected model. Never store keys or raw SDK exceptions in
+reports or fixtures. See `docs/providers.md` and `docs/releasing.md`.

rce_path-0.1.0/LICENSE

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

rce_path-0.1.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.5
+Name: rce-path
+Version: 0.1.0
+Summary: Local-first, evidence-backed Python execution-path investigation
+Author: Sai Teja Erukude
+License-Expression: MIT
+License-File: LICENSE
+Keywords: audit,dataflow,rce,security,static-analysis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Security
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: pydantic<3,>=2.7
+Provides-Extra: ai
+Requires-Dist: ollama<1,>=0.4.7; extra == 'ai'
+Requires-Dist: openai<3,>=1.68; extra == 'ai'
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: mypy>=1.15; extra == 'dev'
+Requires-Dist: pytest<10,>=8; extra == 'dev'
+Requires-Dist: ruff>=0.11; extra == 'dev'
+Requires-Dist: twine>=6; extra == 'dev'
+Provides-Extra: ollama
+Requires-Dist: ollama<1,>=0.4.7; extra == 'ollama'
+Provides-Extra: openai
+Requires-Dist: openai<3,>=1.68; extra == 'openai'
+Description-Content-Type: text/markdown
+
+# rce-path
+
+Trace potentially untrusted Python inputs to execution sinks, with source
+locations and static flow evidence. Scans local code without executing it.
+
+## Install
+
+```bash
+python -m pip install .
+# Optional AI backends: ".[openai]" or ".[ollama]"
+```
+
+After publishing: `pip install rce-path`.
+
+## Quick start
+
+```bash
+rce-path scan ./checkout --format json --output findings.json
+rce-path scan ./checkout --format markdown --output report.md
+```
+
+```python
+from rce_path import scan
+
+report = scan("./checkout")
+print(report.summary)
+```
+
+## Features
+
+- Detects `eval`, `exec`, OS shell calls, and subprocess shell execution.
+- Tracks parameters, Flask request data, and local inputs through assignments,
+  branches, and bounded loops.
+- Exports evidence, assumptions, coverage diagnostics, and stable fingerprints.
+- Supports optional OpenAI and Ollama reviews.
+
+Static findings require human review. Remote AI code transmission requires
+`--allow-remote-code`. Exit codes: **0** completed, **1** findings policy failed,
+**2** incomplete scan or operational error.
+
+[Usage & limitations](docs/usage.md) · [Configuration](examples/rce-path.toml) ·
+[AI providers](docs/providers.md) · [Contributing](CONTRIBUTING.md) ·
+[Publishing](docs/releasing.md)
+
+Author: Sai Teja Erukude.

rce_path-0.1.0/README.md

@@ -0,0 +1,45 @@
+# rce-path
+
+Trace potentially untrusted Python inputs to execution sinks, with source
+locations and static flow evidence. Scans local code without executing it.
+
+## Install
+
+```bash
+python -m pip install .
+# Optional AI backends: ".[openai]" or ".[ollama]"
+```
+
+After publishing: `pip install rce-path`.
+
+## Quick start
+
+```bash
+rce-path scan ./checkout --format json --output findings.json
+rce-path scan ./checkout --format markdown --output report.md
+```
+
+```python
+from rce_path import scan
+
+report = scan("./checkout")
+print(report.summary)
+```
+
+## Features
+
+- Detects `eval`, `exec`, OS shell calls, and subprocess shell execution.
+- Tracks parameters, Flask request data, and local inputs through assignments,
+  branches, and bounded loops.
+- Exports evidence, assumptions, coverage diagnostics, and stable fingerprints.
+- Supports optional OpenAI and Ollama reviews.
+
+Static findings require human review. Remote AI code transmission requires
+`--allow-remote-code`. Exit codes: **0** completed, **1** findings policy failed,
+**2** incomplete scan or operational error.
+
+[Usage & limitations](docs/usage.md) · [Configuration](examples/rce-path.toml) ·
+[AI providers](docs/providers.md) · [Contributing](CONTRIBUTING.md) ·
+[Publishing](docs/releasing.md)
+
+Author: Sai Teja Erukude.

rce_path-0.1.0/docs/providers.md

@@ -0,0 +1,34 @@
+# Provider validation
+
+`tests/test_providers.py` applies the same contract fixtures to OpenAI and Ollama:
+valid JSON, malformed JSON, refusal, truncation, unavailable model, timeout, rate
+limit, invalid credentials, unsupported schema/options, and invented citations.
+Tests also cover repair/retry bounds, byte/token budgets, cancellation, consent,
+redaction, cache-key invalidation, and preservation of the static evidence.
+Tests use stubs and require no keys or downloads.
+
+For an optional live smoke test, create a temporary file containing:
+
+```python
+def investigate(code):
+    eval(code)
+```
+
+Install the appropriate extra. Start your existing Ollama server and choose a
+model you have already installed; no automatic pulls occur. Then:
+
+```bash
+rce-path scan smoke.py --ai ollama --model YOUR_MODEL --output ollama-review.json
+rce-path scan smoke.py --ai openai --model YOUR_MODEL --allow-remote-code --output openai-review.json
+```
+
+For OpenAI, supply `OPENAI_API_KEY` through the environment. Verify `ai_status`,
+cited evidence IDs, usage, static fingerprint, and provider/model identity. An
+unsupported schema/model is a failed review, not a reason to silently drop options.
+Do not run live tests in standard CI. Local model refusals can appear as
+schema-invalid output if the model does not emit a structured refusal marker;
+either result is explicitly unsuccessful.
+
+Implementation references: [OpenAI structured output](https://developers.openai.com/api/docs/guides/structured-outputs),
+[Ollama structured output](https://docs.ollama.com/capabilities/structured-outputs),
+and [Ollama chat API](https://docs.ollama.com/api/chat).

rce_path-0.1.0/docs/releasing.md

@@ -0,0 +1,63 @@
+# Releasing rce-path
+
+The repository builds version 0.1.0 as a wheel and source distribution. Before a
+public release, verify availability/ownership of the normalized name `rce-path`
+on PyPI and TestPyPI. Configure the repository URL in project metadata after the
+actual GitHub repository exists. The publishing workflow lives in
+`.github/workflows/publish.yml`.
+
+```bash
+python -m pip install -e ".[dev]"
+python -m pytest
+python -m ruff check src tests
+python -m mypy
+python -m build
+python -m twine check dist/*
+```
+
+Install the built wheel in a fresh environment and run `rce-path --version` and
+`rce-path scan --help`. Run `python scripts/check_install.py` with that environment's
+Python for an offline CLI, metadata, typed-marker, and non-execution smoke test.
+CI runs one Ubuntu job on Python 3.13 for branch pushes and pull requests. The labeled
+fixture gate checks all supported classifications, sink spans, safe controls,
+top-level non-execution, and limits. Provider tests run without external access.
+
+To test upload manually (an explicit publishing action):
+
+```bash
+python -m twine upload --repository testpypi dist/*
+```
+
+Use your TestPyPI credentials and install the exact version in a clean environment.
+Install Pydantic from PyPI first, then install the package from TestPyPI with
+`--no-deps` to avoid mixing dependency indexes. See the
+[official TestPyPI guide](https://packaging.python.org/en/latest/guides/using-testpypi/).
+
+For GitHub/PyPI trusted publishing:
+
+1. Create the GitHub repository and commit this project, including its workflows.
+2. Configure a pending/active PyPI publisher for `rce-path`, the repository owner
+   and name, workflow `publish.yml`, and environment `pypi`.
+3. Create/protect the GitHub `pypi` environment with required reviewers.
+4. Ensure `pyproject.toml`, `rce_path.__version__`, CLI version, and report version
+   agree; tag the commit `rce-path-v0.1.0` and push that tag.
+5. The workflow verifies version, runs tests/checks, builds and checks artifacts,
+   then publishes through OIDC. It does not use a stored PyPI API token.
+
+The workflow is present but needs a GitHub repository and PyPI publisher setup.
+Use a new version for each upload; PyPI does not allow overwriting a release.
+
+After configuring the publisher, commit and push your changes, then publish 0.1.0:
+
+```bash
+git push origin main
+git tag rce-path-v0.1.0
+git push origin rce-path-v0.1.0
+```
+
+A normal branch push runs CI; publishing runs on `rce-path-v*` tags. The tag's
+version must match `pyproject.toml`. Alternatively, open GitHub Actions, select
+**Publish to PyPI**, and use **Run workflow** to publish the version from your
+selected branch. The manual button appears once the workflow is on the default
+branch. Both release paths run validation before uploading and honor the `pypi`
+environment's approval rules. Branch pushes do not upload to PyPI.

rce_path-0.1.0/docs/usage.md

@@ -0,0 +1,169 @@
+# Usage and limitations
+
+Investigate potentially untrusted Python inputs reaching execution sinks, with
+reproducible source locations and ordered static evidence. Built for researchers
+reviewing local checkouts. **Phase 1, version 0.1.0; Python 3.11+.**
+
+Author: Sai Teja Erukude. License: MIT. Uses the src layout, Hatch builds, typed API,
+pytest, and trusted publishing conventions of `rai-audit`.
+
+An execution sink is not automatically a vulnerability. Static flow does not prove
+exploitability, deployment exposure, or remote code execution. Reports assign no
+automatic severity, CVSS, or exploitability probability.
+
+## Installation
+
+From this checkout:
+
+```bash
+python -m pip install .
+python -m pip install ".[openai]"  # optional official OpenAI SDK
+python -m pip install ".[ollama]"  # optional official Ollama client
+```
+
+After publishing, the equivalent PyPI installation is `pip install rce-path`.
+The static scanner needs only Pydantic; it does not load either AI SDK.
+
+## Quick start
+
+```bash
+rce-path scan ./checkout --format json --output findings.json
+rce-path scan ./checkout --format markdown --output report.md
+rce-path scan ./checkout --fail-on static-path
+```
+
+```python
+from rce_path import ScanConfig, scan
+
+report = scan("./checkout", config=ScanConfig(ai_enabled=False))
+print(report.summary)
+for finding in report.findings:
+    print(finding.rule_id, finding.location.file, finding.location.line)
+    for step in finding.steps:
+        print(step.kind, step.location.line, step.description)
+```
+
+`rce-path` is the distribution/command name; `rce_path` is the Python import name.
+Scan a directory or an individual `.py` file. Report methods include `to_json()`
+and `to_markdown()`; public records are validated, typed Pydantic models.
+
+## Phase 1 models
+
+- `eval`/`exec`, including builtin imports and common aliases.
+- `os.system`/`os.popen`, including module/from imports and assignment aliases.
+- `subprocess.run`, `call`, `check_call`, `check_output`, `Popen` with shell execution;
+  `getoutput` and `getstatusoutput` always imply shell execution. Unknown shell
+  values carry an explicit condition. `shell=False` scenarios produce limitations.
+- Function parameters, Flask `request.args`, `request.form`, `request.data`, and
+  `request.get_data()`. Environment, CLI, stdin, and file reads are local input.
+- Assignments, reassignment, concatenation, f-strings, branches, early returns,
+  and bounded loop fixed points over per-scope control-flow graphs.
+
+Literal-only sinks are negative controls. Unknown return values produce
+`sink_only` findings and unresolved evidence; unknown calls never propagate an
+invented path and are never automatically treated as sanitizers. A guard or
+escaping function does not prove the argument safe. Branch joins are conservative
+overapproximations and can retain mutually exclusive conditions.
+
+Every finding includes a stable fingerprint, rule/schema versions, exact relative
+file spans (columns are AST UTF-8 byte offsets, zero based), source category,
+evidence tier, ordered evidence, assumptions, unresolved calls, and review state.
+`network_source_modeled` means a modeled network input, with authentication and
+deployment still unknown. Fingerprints exclude AI annotations and absolute roots.
+Content hashes cover read source files; revision is unknown unless supplied by a
+future trusted provenance integration. Dependency-version provenance is empty in
+Phase 1 because its rules are not dependency-version-sensitive.
+
+## Safety, completion, and coverage
+
+Targets are read as data: no imports, package installation, target build hooks,
+deserialization, or checkpoint loading. Excluded environments/build trees and
+skipped files appear in diagnostics. Symlinks/reparse points are not followed.
+Isolated parser/analysis workers enforce wall time, memory, AST, flow, and evidence
+budgets. Windows uses Job Objects; POSIX uses `RLIMIT_AS`. If enforcement fails,
+the worker fails and the report is incomplete. Source inventory and the static
+scan also have overall time/file/inventory limits. The total scan deadline includes
+requested AI reviews; each review also has its own timeout and token budget.
+
+Exit codes: **0** completed and selected policy passed; **1** findings policy
+failed; **2** operational/configuration error, incomplete static scan, or requested
+AI review failed. `--fail-on none` is the default. Incomplete status wins over a
+findings policy. A complete empty report says only **“No modeled findings.”**
+Read coverage diagnostics even when the status is completed.
+
+Supported target syntax follows the running Python interpreter (recorded in each
+report). A Python 3.11 runtime cannot parse newer syntax. Cross-file/function flow,
+closures, dynamic dispatch, complex heap mutation, comprehensions, and precise
+exception/finally flow are outside Phase 1 coverage. Known unsupported constructs
+produce diagnostics. Parsing is isolated and bounded, but this scanner is not a
+general-purpose sandbox for running hostile code. Avoid concurrently modifying
+the checkout during a scan.
+
+## Configuration
+
+Use [`examples/rce-path.toml`](../examples/rce-path.toml) as a starter. `scan(path)`
+and the CLI discover `rce-path.toml` at the scan root. Passing `ScanConfig` directly
+uses exactly that configuration; the CLI also accepts `--config PATH`.
+Unknown keys and invalid budgets fail explicitly. Exclusion patterns use forward
+slashes. Repository configuration cannot enable AI, supply credentials, or grant
+remote transmission permission. AI model/provider settings take effect only after
+runtime opt-in. Repository AI endpoints are ignored unless the operator supplies
+`--accept-config-ai-endpoint`; an explicit `--endpoint` takes precedence.
+
+## Optional AI annotations
+
+```bash
+rce-path scan ./checkout --ai ollama --model YOUR_MODEL --format markdown
+rce-path scan ./checkout --ai openai --model YOUR_MODEL --allow-remote-code
+```
+
+Set `OPENAI_API_KEY` in the operator environment for OpenAI. Model names are always
+operator-selected. OpenAI uses the official Responses API with strict structured
+output and `store=False`; this is not a zero-retention promise. Ollama uses native
+`/api/chat` with a JSON schema; the default is `http://127.0.0.1:11434`.
+
+OpenAI and non-loopback Ollama endpoints require `--allow-remote-code`. Numeric
+loopback addresses are recognized; hostnames, including `localhost`, conservatively
+require consent to avoid DNS trust assumptions. No automatic cloud fallback.
+Only bounded evidence slices are sent, with best-effort known-secret redaction.
+Redaction can miss secrets; review your inputs before allowing transmission.
+The scanner does not log raw prompts/source or provider exception bodies.
+
+Both providers share `review(EvidenceBundle, ReviewConfig) -> ReviewResult`, validate
+cited evidence IDs, and annotate without altering findings. Malformed output gets
+at most one repair. Refusals/authentication failures do not trigger repairs.
+Only transient failures retry with backoff and jitter. Requests are serial per
+provider, with timeout, input/output size, context, review-count, and total token
+budgets. Byte-based input token reservations are deliberately conservative;
+actual tokenizer/context accounting varies by model. Temperature is omitted
+unless explicitly declared supported through `ReviewConfig`.
+
+`ai_status` distinguishes completed, refused, invalid_output, unsupported,
+unavailable, and budget_exceeded. Failed reviews never appear successful.
+Cancellation is available through `Cancellation` when constructing a provider;
+in-flight transport completes or times out before cancellation takes effect.
+No application cache is enabled or persisted; a versioned `cache_key()` helper is
+provided for a future operator-controlled cache. Unknown model revisions remain
+explicit. See [provider testing](providers.md) for optional live smoke tests.
+
+## Development and publishing
+
+```bash
+python -m pip install -e ".[dev]"
+python -m pytest
+python -m ruff check src tests
+python -m mypy
+python -m build
+python -m twine check dist/*
+```
+
+See [CONTRIBUTING.md](../CONTRIBUTING.md) and [release instructions](releasing.md)
+for TestPyPI, PyPI trusted publishing, and the version/tag checks. Nothing in a
+normal scan uploads code. No publishing occurs when running the tests/build.
+
+The full [specification](../rce-path_spec.md) guides module boundaries. Phase 2 will
+add bounded local call summaries, deserialization/version-aware rules, framework
+and process models, independent AI review, evaluation, and SARIF. Phase 3 will add
+separate human-approved validation and evidence bundles. Those phases are not
+implemented in this release. Phase 1's P1 external rule-file enhancement is deferred.
+

rce_path-0.1.0/examples/investigate.py

@@ -0,0 +1,15 @@
+"""Library usage. The specified target is inspected, never imported."""
+
+from pathlib import Path
+
+from rce_path import ScanConfig, scan
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("target")
+    args = parser.parse_args()
+    report = scan(args.target, ScanConfig(ai_enabled=False))
+    Path("findings.json").write_text(report.to_json(), encoding="utf-8")
+    print(report.summary)

rce_path-0.1.0/examples/rce-path.toml

@@ -0,0 +1,23 @@
+[scan]
+rules = ["python.eval", "python.exec", "os.system", "os.popen", "subprocess.shell"]
+excludes = [".git", ".venv", "venv", "__pycache__", "build", "dist", "node_modules", "site-packages"]
+max_file_bytes = 1000000
+max_files = 10000
+parser_timeout_seconds = 10.0
+parser_memory_mb = 256
+scan_timeout_seconds = 120.0
+max_ast_nodes = 30000
+max_flow_steps = 20000
+loop_iterations = 8
+max_evidence_steps = 64
+
+[ai]
+provider = "ollama"
+model = "YOUR_MODEL"
+timeout_seconds = 30.0
+max_reviews = 20
+max_input_bytes = 16000
+max_output_tokens = 1024
+total_token_budget = 50000
+# Runtime --ai is required. Endpoint settings require explicit acceptance.
+# endpoint = "http://127.0.0.1:11434"

rce_path-0.1.0/pyproject.toml

@@ -0,0 +1,63 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "rce-path"
+version = "0.1.0"
+description = "Local-first, evidence-backed Python execution-path investigation"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{name = "Sai Teja Erukude"}]
+requires-python = ">=3.11"
+keywords = ["security", "static-analysis", "dataflow", "rce", "audit"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Topic :: Security",
+  "Typing :: Typed",
+]
+dependencies = ["pydantic>=2.7,<3"]
+
+[project.optional-dependencies]
+openai = ["openai>=1.68,<3"]
+ollama = ["ollama>=0.4.7,<1"]
+ai = ["openai>=1.68,<3", "ollama>=0.4.7,<1"]
+dev = ["pytest>=8,<10", "build>=1.2", "twine>=6", "ruff>=0.11", "mypy>=1.15"]
+
+[project.scripts]
+rce-path = "rce_path.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/rce_path"]
+
+[tool.hatch.build.targets.sdist]
+include = ["/src", "/tests", "/docs", "/examples", "/scripts", "/README.md", "/LICENSE", "/pyproject.toml", "/rce-path_spec.md", "/.github", "/CONTRIBUTING.md"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+addopts = "--import-mode=importlib"
+
+[tool.ruff]
+target-version = "py311"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F", "I", "UP"]
+
+[tool.mypy]
+python_version = "3.11"
+files = ["src/rce_path"]
+check_untyped_defs = true
+
+[[tool.mypy.overrides]]
+# The static/dev installation intentionally excludes these optional AI SDKs.
+module = ["openai.*", "ollama.*"]
+ignore_missing_imports = true