quarry-db 0.2.0__tar.gz

quarry_db-0.2.0/.claude/launch.json

@@ -0,0 +1,11 @@
+{
+  "version": "0.0.1",
+  "configurations": [
+    {
+      "name": "quarry-gui",
+      "runtimeExecutable": "python",
+      "runtimeArgs": ["-c", "from quarry import gui; gui.serve(port=8792, open_browser=False)"],
+      "port": 8792
+    }
+  ]
+}

quarry_db-0.2.0/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,21 @@
+---
+name: Bug report
+about: Something broke
+labels: bug
+---
+
+**What happened**
+
+**What you expected**
+
+**Reproduce**
+
+```bash
+# minimal commands / SQL / connections.toml (redact credentials!)
+```
+
+**Environment**
+- Quarry version (`qy --version` or `pip show quarry-db`):
+- Engine (postgres/mysql/redis) + server version:
+- OS / Python version:
+- Exit code, if using the CLI:

quarry_db-0.2.0/.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,15 @@
+---
+name: Feature request
+about: An idea for Quarry
+labels: enhancement
+---
+
+**The problem**
+<!-- What are you trying to do that Quarry can't (or makes painful)? -->
+
+**Proposed solution**
+
+**Which face(s) does it touch?**
+<!-- kernel / CLI / GUI / agent-skill / MCP -->
+
+**Does it interact with the safety rails or the result/exit-code contract?**

quarry_db-0.2.0/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,7 @@
+**What & why**
+
+**Checklist**
+- [ ] Tests added/updated, `python3 -m pytest -q` passes
+- [ ] Kernel stays stdlib-only (new deps are optional extras)
+- [ ] Safety rails unaffected, or the change is discussed in an issue
+- [ ] Result shape / exit codes unchanged (or additive only)

quarry_db-0.2.0/.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: monthly

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

@@ -0,0 +1,63 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+
+    services:
+      postgres:
+        image: postgres:16
+        env:
+          POSTGRES_USER: quarry
+          POSTGRES_PASSWORD: quarry
+          POSTGRES_DB: quarry_test
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd "pg_isready -U quarry"
+          --health-interval 5s
+          --health-timeout 5s
+          --health-retries 10
+
+    env:
+      QUARRY_TEST_DB_URL: postgresql://quarry:quarry@localhost:5432/quarry_test
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install psql client
+        run: sudo apt-get update && sudo apt-get install -y --no-install-recommends postgresql-client
+
+      - name: Install package
+        run: pip install -e ".[dev]"
+
+      - name: Seed test database
+        run: psql "$QUARRY_TEST_DB_URL" -f tests/seed.sql
+
+      - name: Run tests
+        run: python3 -m pytest -q
+
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Build sdist + wheel
+        run: pipx run build
+      - name: Check metadata
+        run: pipx run twine check dist/*

quarry_db-0.2.0/.github/workflows/pages.yml

@@ -0,0 +1,31 @@
+name: Deploy site to GitHub Pages
+
+on:
+  push:
+    branches: [main]
+    paths: ["site/**"]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: pages
+  cancel-in-progress: true
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/configure-pages@v5
+      - uses: actions/upload-pages-artifact@v3
+        with:
+          path: site
+      - id: deployment
+        uses: actions/deploy-pages@v4

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

@@ -0,0 +1,21 @@
+name: Release to PyPI
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write   # PyPI Trusted Publishing (no API token needed)
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Build
+        run: pipx run build
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

quarry_db-0.2.0/.gitignore

@@ -0,0 +1,22 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+build/
+dist/
+.venv/
+venv/
+
+# Quarry — never commit a workspace with real connection secrets
+connections.toml
+workspace/
+*.local.toml
+# ...but the credential-free example workspace ships with the repo
+!examples/workspace/
+!examples/workspace/connections.toml
+
+# OS / editor
+.DS_Store
+.idea/
+.vscode/

quarry_db-0.2.0/CHANGELOG.md

@@ -0,0 +1,59 @@
+# Changelog
+
+All notable changes to Quarry are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow
+[SemVer](https://semver.org/) (pre-1.0: minor bumps may break).
+
+## [Unreleased]
+
+## [0.2.0] — 2026-07-02
+
+### Added
+- **MCP face** (`qy mcp`): a Model Context Protocol server over stdio, pure
+  stdlib. Six tools: `list_connections`, `list_tables`, `describe_table`,
+  `exec_sql`, `list_saved_queries`, `run_saved_query`. Graduated write policy:
+  server `--write` flag + per-call `write: true` + `confirm_prod: true` for prod.
+- GUI: multi-tab editor (per-tab SQL + connection, persisted across restarts)
+- GUI: EXPLAIN button (plan modal for postgres, grid for tabular plans)
+- GUI: searchable query history with connection name and relative time
+- GUI: grid keyboard navigation (arrow keys + Enter to inspect)
+- GUI: collapsible JSON tree in the cell inspector
+
+### Fixed
+- SQL errors were silently swallowed into empty results (psql now runs with
+  `ON_ERROR_STOP`; failed statements correctly exit with code 3)
+- `EXPLAIN` / `SHOW` statements now work through `run_query` (previously broken
+  by the JSON subquery wrapper) and are exempt from the auto-LIMIT injection
+
+## [0.1.0] — 2026-07-02
+
+First public release.
+
+### Core
+- Multi-engine query kernel (`quarry.core`): PostgreSQL (via system `psql`),
+  MySQL (optional `pymysql`), Redis (via `redis-cli`)
+- Structured result contract: `{columns, rows, rowCount, truncated, elapsedMs, engine, sql}`
+- Safety rails in the kernel: read-only by default (`--write` to allow),
+  automatic `LIMIT 500` row cap, graduated prod confirmation
+- Stable exit-code contract: `0` ok / `2` connection / `3` SQL / `8` safety block
+- Workspace-as-code: `connections.toml` + named queries (`queries/**/*.sql`
+  with `-- @meta` headers); multi-workspace aggregation via
+  `~/.config/quarry/config.toml`
+- Connection groups and env-sets (same logical db across dev/prod/…,
+  `--env` switch, dev default)
+- SSH tunnels via system `ssh` (`ssh_*` connection fields)
+
+### CLI (`qy`)
+- `connections` (list/add/set/remove/test), `exec`, `run`, `save`, `list`,
+  `describe`, `schema`, `validate`, `fingerprint`, `audit`, `remove`, `edit`,
+  `workspace` (list/add/remove), `gui`
+- Output formats: table / json / ndjson / csv
+
+### GUI (`qy gui`)
+- Local zero-build web GUI, light/dark theme
+- Grouped sidebar tree with environment switcher (prod highlighted red)
+- SQL editor with syntax highlighting and local autocomplete (keywords/tables/columns)
+- Data grid: type-aware coloring, sorting, column resize, cell/row inspection
+- CSV/JSON export, query history, saved-query library
+- TYPE-aware Redis key browsing
+- State persists across restarts (selected connection, SQL, results cache)

quarry_db-0.2.0/CODE_OF_CONDUCT.md

@@ -0,0 +1,7 @@
+# Code of Conduct
+
+This project follows the [Contributor Covenant, version 2.1](https://www.contributor-covenant.org/version/2/1/code_of_conduct/).
+
+In short: be respectful, be constructive, assume good faith. Harassment, personal attacks, and discriminatory language are not tolerated in issues, PRs, discussions, or any other project space.
+
+To report unacceptable behavior, contact the maintainer through GitHub.

quarry_db-0.2.0/CONTRIBUTING.md

@@ -0,0 +1,56 @@
+# Contributing to Quarry
+
+Thanks for your interest! Quarry is young and contributions of all sizes are welcome — bug reports, docs, new engine backends, GUI polish.
+
+## Ground rules (design invariants)
+
+Quarry has a few invariants that PRs must not break. If your change needs to bend one, open an issue first so we can discuss.
+
+1. **The kernel stays dependency-free.** `quarry.core` is pure stdlib. Engine backends may shell out to system binaries (`psql`, `redis-cli`, `ssh`) or use an *optional* extra (like `pymysql`), but nothing gets added to the required dependencies.
+2. **Safety rails live in the kernel, not in the faces.** Read-only enforcement, row caps, and prod confirmation must work identically through the CLI, the GUI, and library calls. Never implement a safety check only in one face.
+3. **The result and exit-code contracts are stable API.** `{columns, rows, rowCount, truncated, elapsedMs, engine, sql}` and exit codes `0/2/3/8` — additive changes only.
+4. **Faces stay thin.** If logic could be useful to more than one face, it belongs in `quarry.core` (or a sibling kernel module), not in `cli.py`/`gui.py`.
+5. **The kernel carries no secrets and no business logic.** Connections and queries always come from a user workspace.
+
+## Development setup
+
+```bash
+git clone https://github.com/Wangggym/quarry && cd quarry
+python3 -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+```
+
+### Running tests
+
+Unit tests run with no setup:
+
+```bash
+python3 -m pytest -q
+```
+
+DB-backed tests need a local PostgreSQL with a seeded `quarry_test` database (they skip automatically if it's unreachable):
+
+```bash
+createdb quarry_test
+psql quarry_test -f tests/seed.sql
+python3 -m pytest -q          # QUARRY_TEST_DB_URL overrides the default URL
+```
+
+## Adding an engine backend
+
+An engine implements: URL parsing, query execution returning the standard result shape, read-only classification for its command/statement set, and (optionally) schema introspection. Look at `redis_engine.py` for the smallest complete example, and how `core.py` dispatches on `engine`. Requirements:
+
+- Prefer shelling out to the engine's standard client binary over adding a Python driver; if a driver is unavoidable, make it an optional extra.
+- Define the read-only command set conservatively — when in doubt, a command is a write.
+- Add unit tests that don't require a live server (parsing, safety classification) plus live tests guarded by a reachability skip.
+
+## Pull requests
+
+- Keep PRs focused; separate refactors from behavior changes.
+- Add or update tests for what you change.
+- `python3 -m pytest -q` must pass.
+- Describe *why*, not just *what*, in the PR body.
+
+## Reporting bugs / proposing features
+
+Use the issue templates. For safety-rail bypasses (a way to execute a write without `--write`), please follow [SECURITY.md](SECURITY.md) instead of opening a public issue.

quarry_db-0.2.0/LICENSE

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

quarry_db-0.2.0/PKG-INFO

@@ -0,0 +1,240 @@
+Metadata-Version: 2.4
+Name: quarry-db
+Version: 0.2.0
+Summary: AI-native database workbench: one safety-railed query kernel, many faces (CLI / GUI / agent skill / MCP)
+Project-URL: Homepage, https://github.com/Wangggym/quarry
+Project-URL: Repository, https://github.com/Wangggym/quarry
+Project-URL: Changelog, https://github.com/Wangggym/quarry/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/Wangggym/quarry/issues
+Author: Wangggym
+License: MIT
+License-File: LICENSE
+Keywords: agent,ai,cli,database,mcp,mysql,postgres,redis,sql,workbench
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Database :: Front-Ends
+Requires-Python: >=3.11
+Provides-Extra: dev
+Requires-Dist: flask>=3.0; extra == 'dev'
+Requires-Dist: pymysql>=1.1; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Provides-Extra: gui
+Requires-Dist: flask>=3.0; extra == 'gui'
+Provides-Extra: mysql
+Requires-Dist: pymysql>=1.1; extra == 'mysql'
+Description-Content-Type: text/markdown
+
+# Quarry
+
+> **The database workbench built for the AI era** — one kernel, many faces (CLI / GUI / MCP / agent skill).
+
+[![CI](https://github.com/Wangggym/quarry/actions/workflows/ci.yml/badge.svg)](https://github.com/Wangggym/quarry/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/quarry-db)](https://pypi.org/project/quarry-db/)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue)](https://pypi.org/project/quarry-db/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+
+[中文文档 →](README.zh-CN.md) · [Website →](https://quarry.yiminlab.site)
+
+![Quarry demo](site/assets/demo.svg)
+
+Every database tool you know — DBeaver, TablePlus, pgAdmin — assumes a *human* at the keyboard. But increasingly, the entity running your queries is an **AI agent**, and agents need different guarantees:
+
+- **Results a machine can parse**, not a screen a human can read
+- **Safety rails that live in the kernel**, so no client can forget them
+- **Deterministic error contracts** (stable exit codes), not stack traces to scrape
+- **Configuration as files**, not clicks — so it can be versioned, diffed, and shared with agents
+
+Quarry inverts the traditional design: it is a **query kernel with an agent-safe contract first**, and the human faces (CLI, GUI) are thin shells grown from the same kernel. Whether a query comes from a person in the browser, a script in CI, or Claude running a skill, it passes through the exact same safety rails and returns the exact same structured result.
+
+## Philosophy
+
+1. **One core, many faces.** Connection management, query execution, schema introspection, and safety rails live in an importable kernel (`quarry.core`). The CLI (`qy`), the GUI, the MCP server, and agent skills are thin shells. Fix a bug once, every face gets it.
+
+2. **Read-only by default; escalation is explicit and graduated.** Writes and DDL are blocked (exit code `8`) unless you pass `--write`. Production connections require an *additional* confirmation on top of `--write`. Every query gets an automatic `LIMIT 500` unless you opt out. Because the rails are in the kernel, an agent cannot bypass them by picking a different entry point.
+
+3. **A contract machines can trust.** Every query returns `{columns, rows, rowCount, truncated, elapsedMs, engine, sql}`. Exit codes are stable API: `0` ok, `2` connection error, `3` SQL error, `8` safety block. An agent can branch on outcomes without parsing prose.
+
+4. **Workspace as code.** A workspace is just a directory: `connections.toml` + `queries/**/*.sql` (named queries with `-- @meta` headers). It lives in *your* repo, versioned by git, shared between teammates and agents alike. The kernel itself carries zero business logic and zero secrets.
+
+5. **Nearly zero dependencies.** Pure stdlib. PostgreSQL goes through your system `psql`, Redis through `redis-cli`, SSH tunnels through system `ssh`. MySQL is one optional `pymysql`. No Electron, no daemon, no cloud.
+
+## Install
+
+```bash
+pipx install quarry-db        # or: pip install quarry-db
+qy --help
+```
+
+PostgreSQL uses the system `psql` binary; MySQL needs `pip install "quarry-db[mysql]"`.
+
+## Quickstart
+
+```bash
+mkdir my-workspace && cd my-workspace
+cat > connections.toml <<'EOF'
+[shop]
+url    = "postgresql://user:pass@localhost:5432/shop"
+engine = "postgres"
+env    = "dev"
+EOF
+
+qy connections                       # list connections
+qy exec shop --sql "select * from customers"
+qy schema shop customers             # table structure (\d+)
+qy gui                               # browser data grid
+```
+
+## Workspace
+
+A workspace directory is the source of connections + queries:
+
+```
+my-workspace/
+├── connections.toml      # [key] url / engine / env / group / notes
+└── queries/<db>/*.sql    # named queries (with -- @meta headers)
+```
+
+Resolution order: `--workspace PATH` → `~/.config/quarry/config.toml` → current directory.
+
+## CLI reference
+
+| Command | Purpose |
+|---------|---------|
+| `qy connections [list\|add\|set\|remove\|test]` | Manage connections |
+| `qy exec <db> --sql "..." [--format json\|ndjson\|csv\|table]` | Run ad-hoc SQL |
+| `qy schema <db> <table>` | Live table structure |
+| `qy run <name> [k=v ...]` | Run a saved named query |
+| `qy save <name> --db X --sql "..."` | Save a named query |
+| `qy list / describe / validate / fingerprint / audit` | Manage named queries |
+| `qy workspace list/add/remove` | Manage aggregated workspaces |
+| `qy gui` | Launch the local GUI |
+| `qy mcp [--write]` | Serve the MCP face over stdio (for AI agents) |
+
+## MCP (the agent-native face)
+
+`qy mcp` speaks the Model Context Protocol over stdio — pure stdlib, no SDK dependency. Agents get six tools (`list_connections`, `list_tables`, `describe_table`, `exec_sql`, `list_saved_queries`, `run_saved_query`) with the exact same kernel rails: read-only unless the server was started with `--write` *and* the call passes `write: true`; a prod env additionally requires `confirm_prod: true`.
+
+```bash
+# Claude Code
+claude mcp add quarry -- qy mcp --workspace ~/my-workspace
+```
+
+```json
+// or any MCP client (.mcp.json)
+{ "mcpServers": { "quarry": { "command": "qy", "args": ["mcp", "--workspace", "/path/to/workspace"] } } }
+```
+
+## Safety rails (the AI-native moat)
+
+- **Read-only by default**: writes/DDL blocked with exit code `8`; `--write` to allow
+- **Automatic row cap**: `run_query()` injects `LIMIT 500`; raise with `--max-rows N`
+- **Graduated prod protection**: all envs default read-only → dev needs `--write` → prod needs `--write` *plus* an interactive confirmation (`--yes` for automation)
+- **Stable exit-code contract**: `0` ok / `2` connection / `3` SQL / `8` safety block
+
+## As a library (what the GUI and agents use)
+
+```python
+from quarry import configure_workspace, get_connection, run_query
+
+configure_workspace("~/my-workspace")
+res = run_query(get_connection("shop"), "select * from customers")
+print(res.to_dict())   # {columns, rows, rowCount, truncated, elapsedMs, engine, sql}
+```
+
+## SSH tunnels
+
+For databases only reachable via a bastion, add `ssh_*` fields and `qy` opens the tunnel automatically (system `ssh`, zero dependencies):
+
+```toml
+[internal_db]
+url      = "postgresql://user:pass@127.0.0.1:5432/appdb"
+engine   = "postgres"
+ssh_host = "bastion.example.com"
+ssh_user = "ubuntu"
+ssh_key  = "~/.ssh/id_ed25519"
+```
+
+## Redis
+
+`engine = "redis"` (uses system `redis-cli`). Queries are redis commands:
+
+```bash
+qy exec cache --sql "SCAN 0 COUNT 100"
+qy exec cache --sql "HGETALL user:42"
+```
+
+Read-only rail applies here too: `GET/SCAN/TYPE/TTL/HGETALL` pass; `SET/DEL/FLUSHALL` are blocked without `--write`. In the GUI, redis keys are clickable with TYPE-aware value display.
+
+## Groups & env-sets
+
+Connections can be organized into **project folders** (`group`) and **env-sets** (same `db`, different `env`, shared schema):
+
+```toml
+[shop_dev]
+url = "postgresql://…dev…/shop";  group = "shop"; db = "shop"; env = "dev"
+[shop_prod]
+url = "postgresql://…prod…/shop"; group = "shop"; db = "shop"; env = "prod"
+```
+
+- Connections with the same `db` fold into one env-set — one saved query runs against any environment: `qy exec shop --env prod`
+- Unspecified env defaults to `dev` (the safest)
+- The GUI shows an environment switcher (prod turns red)
+
+## Multiple workspaces
+
+`qy` aggregates all workspaces listed in `~/.config/quarry/config.toml` — one GUI/CLI over all your projects:
+
+```bash
+qy workspace add ~/projects/acme/db-workspace
+qy workspace add ~/projects/side-project/db
+qy connections    # both projects, grouped
+qy gui            # sidebar shows both groups side by side
+```
+
+`--workspace a:b` (os.pathsep-separated) works as a temporary override; the first directory is primary for writes.
+
+## GUI
+
+![Quarry GUI](site/assets/gui-dark.png)
+
+`qy gui` — a local, zero-build web GUI (Slate & Copper theme, light/dark):
+
+- Grouped sidebar tree with env switcher (prod turns red), connection health dots
+- **Multi-tab editor** — each tab remembers its SQL + connection, across restarts
+- SQL highlighting + local autocomplete (keywords / tables / columns)
+- **EXPLAIN button** — one click to the query plan
+- Type-aware data grid: sorting, column resize, **keyboard navigation** (arrows + Enter), cell inspection with a **collapsible JSON tree**
+- CSV/JSON export, **searchable query history** (with connection + time)
+- TYPE-aware Redis key browsing
+
+## Roadmap
+
+- Column types in the result contract for all engines
+- SQLite & DuckDB engines (zero-setup local demo)
+- Redis key-namespace folding tree
+- Cross-environment schema/data diff
+- Write audit log (who ran what, where, when)
+- Single-binary distribution
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+createdb quarry_test && psql quarry_test -f tests/seed.sql
+python3 -m pytest -q
+```
+
+DB-backed tests skip automatically when Postgres is unreachable; unit tests always run. See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+Quarry is developed and tested on macOS and Linux. Windows is currently untested (the psql/ssh integration and port takeover are Unix-flavored) — PRs welcome.
+
+## License
+
+[MIT](LICENSE)