claude-overnight 0.1.0__tar.gz

claude_overnight-0.1.0/.claude-plugin/marketplace.json

@@ -0,0 +1,11 @@
+{
+  "name": "claude-overnight",
+  "owner": { "name": "Rohan Richard" },
+  "plugins": [
+    {
+      "name": "claude-overnight",
+      "source": "./",
+      "description": "Queue research questions with /queue; they run when your usage limits reset overnight."
+    }
+  ]
+}

claude_overnight-0.1.0/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "claude-overnight",
+  "version": "0.1.0",
+  "description": "Queue research questions with /queue; they run when your usage limits reset overnight. Requires the claude-overnight CLI (uv tool install claude-overnight).",
+  "author": { "name": "Rohan Richard" },
+  "homepage": "https://github.com/rohanprichard/claude-overnight",
+  "license": "MIT",
+  "keywords": ["queue", "rate-limits", "overnight", "research"]
+}

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

@@ -0,0 +1,20 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: macos-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: uv sync
+      - run: uv run pytest -q

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

@@ -0,0 +1,18 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv build
+      - uses: pypa/gh-action-pypi-publish@release/v1

claude_overnight-0.1.0/.gitignore

@@ -0,0 +1,12 @@
+# local marketing material — intentionally not published
+promo/
+
+__pycache__/
+*.pyc
+.pytest_cache/
+.venv/
+dist/
+build/
+*.egg-info/
+.DS_Store
+uv.lock

claude_overnight-0.1.0/LICENSE

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

claude_overnight-0.1.0/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: claude-overnight
+Version: 0.1.0
+Summary: Queue research questions all day. Wake up to answers. Puts your idle Claude Code quota to work while you sleep.
+Project-URL: Homepage, https://github.com/rohanprichard/claude-overnight
+Project-URL: Issues, https://github.com/rohanprichard/claude-overnight/issues
+Author: Rohan Richard
+License: MIT
+License-File: LICENSE
+Keywords: automation,claude,claude-code,queue,rate-limits
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# claude-overnight
+
+**Queue research questions all day. Wake up to answers.**
+
+![demo](assets/demo.gif)
+
+Your Claude Code weekly limit quietly expires while you sleep — if you hit the 5-hour cap every day, you still leave weekly quota on the table every single night. `claude-overnight` puts that idle quota to work: queue questions with `/queue` during the day, and a scheduler runs them headlessly inside your configured night window, when your limits have reset. You wake up to a folder of markdown research reports and a morning digest.
+
+```
+you (2:14 pm) ──▶ /queue what are the tradeoffs of CRDTs vs OT for a collab editor?
+you (5:40 pm) ──▶ /queue compare litestream vs. postgres logical replication for a side project
+
+              💤  3:00 am — limits reset, window open, batch runs
+
+you (8:05 am) ──▶ ~/.overnight/results/index.md
+                  ✅ tradeoffs of CRDTs vs OT — crdts-vs-ot.md
+                  ✅ litestream vs postgres replication — litestream-vs-postgres.md
+```
+
+## Why
+
+- **Limit-aware, not just time-aware.** Cron can run Claude at 3am, but it doesn't know whether your 5-hour window is fresh or your weekly cap is nearly gone. `claude-overnight` checks both before starting and *between every job*, and stops at a configurable threshold so you wake up with quota left for actual work.
+- **Runs on your subscription, unattended.** Jobs execute through `claude -p` (headless mode) with tools restricted to web search — no API key, no extra cost.
+- **Zero dependencies.** Pure Python standard library. `uv tool install claude-overnight` and you're done.
+
+## Install
+
+```sh
+uv tool install claude-overnight   # or: pipx install claude-overnight
+overnight install                  # sets up the scheduler + /queue slash command
+```
+
+`overnight install` does two things:
+
+1. Registers a **launchd agent** that wakes every 30 minutes, checks whether you're inside the night window and under the limit thresholds, and runs the queue if so.
+2. Drops a **`/queue` slash command** into `~/.claude/commands/`, so you can queue questions without leaving Claude Code.
+
+Requires macOS, Python 3.11+, and the [Claude Code](https://code.claude.com) CLI with a Pro/Max subscription.
+
+## Use
+
+```sh
+# from anywhere
+overnight add "how do sqlite WAL checkpoints actually work?"
+
+# or inside any Claude Code session
+/queue how do sqlite WAL checkpoints actually work?
+
+overnight list        # see the queue
+overnight status      # current 5h/weekly utilization + would-it-run-now
+overnight run --force # run the batch right now, ignoring window/limits
+```
+
+Results land in `~/.overnight/results/<date>/`, one markdown report per question, with a rolling `index.md` digest. A macOS notification fires when the batch finishes.
+
+## Configure
+
+`~/.overnight/config.toml`:
+
+```toml
+[window]
+start = "01:00"   # jobs only run between these local times
+end = "07:00"     # windows may cross midnight ("23:00" → "06:00")
+
+[limits]
+start_max_utilization = 20   # don't start if the 5h window is already >20% used
+stop_utilization = 60        # stop the batch once 5h usage crosses 60%
+weekly_max_utilization = 80  # never run if the weekly limit is >80% used
+
+[run]
+model = "sonnet"
+job_timeout_minutes = 15
+max_attempts = 2
+```
+
+## How it works (there's no official API)
+
+Claude Code doesn't expose a usage API — but it stores an OAuth token locally (macOS Keychain / `~/.claude/.credentials.json`), and the community discovered that `GET https://api.anthropic.com/api/oauth/usage` with that token returns your 5-hour and weekly utilization with reset timestamps. `claude-overnight` uses that to decide when it's safe to run.
+
+Because the endpoint is **undocumented and could change**, everything degrades gracefully: if usage can't be read, the runner proceeds optimistically and detects limit errors from `claude -p` output instead — a job that hits the limit is requeued untouched for the next window, and the batch stops.
+
+Full details in [docs/how-it-works.md](docs/how-it-works.md).
+
+## Edge cases handled
+
+- **Mac asleep at 3am** — launchd runs the missed tick on wake, so the batch runs when you open the lid, still before you start working.
+- **One job eating the whole window** — per-job timeouts plus utilization re-checks between jobs.
+- **Two runners racing** — lockfile with stale-lock recovery.
+- **Headless Claude wanting to ask you something** — the prompt template instructs it to make reasonable assumptions and state them.
+- **Weekly cap already blown** — the runner skips the batch and says why in `overnight status`.
+
+## Uninstall
+
+```sh
+overnight uninstall            # removes the launchd agent + slash command
+uv tool uninstall claude-overnight
+rm -rf ~/.overnight            # queue, results, config
+```
+
+## Roadmap
+
+- Repo-scoped coding jobs (run in a git worktree, results as branches)
+- Linux (systemd timer) support
+- "Quota saved this week" stats in `overnight status`
+
+## License
+
+MIT

claude_overnight-0.1.0/README.md

@@ -0,0 +1,108 @@
+# claude-overnight
+
+**Queue research questions all day. Wake up to answers.**
+
+![demo](assets/demo.gif)
+
+Your Claude Code weekly limit quietly expires while you sleep — if you hit the 5-hour cap every day, you still leave weekly quota on the table every single night. `claude-overnight` puts that idle quota to work: queue questions with `/queue` during the day, and a scheduler runs them headlessly inside your configured night window, when your limits have reset. You wake up to a folder of markdown research reports and a morning digest.
+
+```
+you (2:14 pm) ──▶ /queue what are the tradeoffs of CRDTs vs OT for a collab editor?
+you (5:40 pm) ──▶ /queue compare litestream vs. postgres logical replication for a side project
+
+              💤  3:00 am — limits reset, window open, batch runs
+
+you (8:05 am) ──▶ ~/.overnight/results/index.md
+                  ✅ tradeoffs of CRDTs vs OT — crdts-vs-ot.md
+                  ✅ litestream vs postgres replication — litestream-vs-postgres.md
+```
+
+## Why
+
+- **Limit-aware, not just time-aware.** Cron can run Claude at 3am, but it doesn't know whether your 5-hour window is fresh or your weekly cap is nearly gone. `claude-overnight` checks both before starting and *between every job*, and stops at a configurable threshold so you wake up with quota left for actual work.
+- **Runs on your subscription, unattended.** Jobs execute through `claude -p` (headless mode) with tools restricted to web search — no API key, no extra cost.
+- **Zero dependencies.** Pure Python standard library. `uv tool install claude-overnight` and you're done.
+
+## Install
+
+```sh
+uv tool install claude-overnight   # or: pipx install claude-overnight
+overnight install                  # sets up the scheduler + /queue slash command
+```
+
+`overnight install` does two things:
+
+1. Registers a **launchd agent** that wakes every 30 minutes, checks whether you're inside the night window and under the limit thresholds, and runs the queue if so.
+2. Drops a **`/queue` slash command** into `~/.claude/commands/`, so you can queue questions without leaving Claude Code.
+
+Requires macOS, Python 3.11+, and the [Claude Code](https://code.claude.com) CLI with a Pro/Max subscription.
+
+## Use
+
+```sh
+# from anywhere
+overnight add "how do sqlite WAL checkpoints actually work?"
+
+# or inside any Claude Code session
+/queue how do sqlite WAL checkpoints actually work?
+
+overnight list        # see the queue
+overnight status      # current 5h/weekly utilization + would-it-run-now
+overnight run --force # run the batch right now, ignoring window/limits
+```
+
+Results land in `~/.overnight/results/<date>/`, one markdown report per question, with a rolling `index.md` digest. A macOS notification fires when the batch finishes.
+
+## Configure
+
+`~/.overnight/config.toml`:
+
+```toml
+[window]
+start = "01:00"   # jobs only run between these local times
+end = "07:00"     # windows may cross midnight ("23:00" → "06:00")
+
+[limits]
+start_max_utilization = 20   # don't start if the 5h window is already >20% used
+stop_utilization = 60        # stop the batch once 5h usage crosses 60%
+weekly_max_utilization = 80  # never run if the weekly limit is >80% used
+
+[run]
+model = "sonnet"
+job_timeout_minutes = 15
+max_attempts = 2
+```
+
+## How it works (there's no official API)
+
+Claude Code doesn't expose a usage API — but it stores an OAuth token locally (macOS Keychain / `~/.claude/.credentials.json`), and the community discovered that `GET https://api.anthropic.com/api/oauth/usage` with that token returns your 5-hour and weekly utilization with reset timestamps. `claude-overnight` uses that to decide when it's safe to run.
+
+Because the endpoint is **undocumented and could change**, everything degrades gracefully: if usage can't be read, the runner proceeds optimistically and detects limit errors from `claude -p` output instead — a job that hits the limit is requeued untouched for the next window, and the batch stops.
+
+Full details in [docs/how-it-works.md](docs/how-it-works.md).
+
+## Edge cases handled
+
+- **Mac asleep at 3am** — launchd runs the missed tick on wake, so the batch runs when you open the lid, still before you start working.
+- **One job eating the whole window** — per-job timeouts plus utilization re-checks between jobs.
+- **Two runners racing** — lockfile with stale-lock recovery.
+- **Headless Claude wanting to ask you something** — the prompt template instructs it to make reasonable assumptions and state them.
+- **Weekly cap already blown** — the runner skips the batch and says why in `overnight status`.
+
+## Uninstall
+
+```sh
+overnight uninstall            # removes the launchd agent + slash command
+uv tool uninstall claude-overnight
+rm -rf ~/.overnight            # queue, results, config
+```
+
+## Roadmap
+
+- Repo-scoped coding jobs (run in a git worktree, results as branches)
+- Linux (systemd timer) support
+- "Quota saved this week" stats in `overnight status`
+
+## License
+
+MIT

claude_overnight-0.1.0/commands/queue.md

@@ -0,0 +1,12 @@
+---
+description: Queue a question for claude-overnight to research when your limits reset
+allowed-tools: Bash(overnight add:*), Bash(overnight status:*)
+---
+
+Queue the user's question for overnight research.
+
+1. Run `overnight add "$ARGUMENTS"`.
+2. If the command is not found, tell the user to install the CLI first:
+   `uv tool install claude-overnight && overnight install`.
+3. On success, confirm the question was queued and mention it will run in
+   the next overnight window (they can check with `overnight status`).

claude_overnight-0.1.0/docs/configuration.md

@@ -0,0 +1,57 @@
+# Configuration
+
+Everything lives in `~/.overnight/config.toml`, created with defaults on first run (`overnight install` or any command). Set `OVERNIGHT_HOME` to relocate the whole state directory.
+
+```toml
+[window]
+start = "01:00"
+end = "07:00"
+
+[limits]
+start_max_utilization = 20
+stop_utilization = 60
+weekly_max_utilization = 80
+
+[run]
+model = "sonnet"
+job_timeout_minutes = 15
+max_attempts = 2
+extra_args = []
+```
+
+## `[window]`
+
+| Key | Default | Meaning |
+| --- | --- | --- |
+| `start`, `end` | `01:00` / `07:00` | Local times bounding when batches may run. `start = "23:00", end = "06:00"` crosses midnight and works as expected. |
+
+Pick a window that starts *after* your last coding session's 5-hour window has reset, and ends *before* you start work. The runner ticks every 30 minutes inside the window, so a batch blocked at 1:00 (limits still hot) will retry at 1:30, 2:00, …
+
+## `[limits]`
+
+| Key | Default | Meaning |
+| --- | --- | --- |
+| `start_max_utilization` | `20` | Don't start a batch unless the 5-hour window is at most this % used. |
+| `stop_utilization` | `60` | Stop the batch once 5-hour usage reaches this %. What's left is your morning buffer. |
+| `weekly_max_utilization` | `80` | Never run if weekly usage exceeds this %. Protects your work-week quota. |
+
+If usage can't be read at all (expired token, endpoint changed), the runner proceeds and stops on the first limit error instead.
+
+## `[run]`
+
+| Key | Default | Meaning |
+| --- | --- | --- |
+| `model` | `sonnet` | Passed to `claude --model`. Use `haiku` to stretch quota further, `opus` for depth. |
+| `job_timeout_minutes` | `15` | Hard kill per job. |
+| `max_attempts` | `2` | Failed/limit-hit jobs are retried on later ticks up to this many times. |
+| `extra_args` | `[]` | Extra flags appended to the `claude -p` invocation, e.g. `["--fallback-model", "haiku"]`. |
+
+## Paths
+
+| Path | Contents |
+| --- | --- |
+| `~/.overnight/queue/` | One JSON file per job |
+| `~/.overnight/results/<date>/` | Markdown reports |
+| `~/.overnight/results/index.md` | Rolling digest, newest batch last |
+| `~/.overnight/logs/` | launchd runner stdout/stderr |
+| `~/Library/LaunchAgents/com.claude-overnight.runner.plist` | The scheduler |

claude_overnight-0.1.0/docs/design.md

@@ -0,0 +1,46 @@
+# Design
+
+*Spec for claude-overnight v0.1, 2026-07-15.*
+
+## Problem
+
+Claude Code Pro/Max plans have a rolling 5-hour limit and a weekly limit. Heavy users hit the 5-hour cap daily yet still leave weekly quota unused, because nights are idle. That surplus expires silently.
+
+## Goal
+
+Let a user queue research questions at any time, and run them unattended overnight — inside a configurable window, only when limits have actually reset, stopping before the fresh window is spent — with results delivered as markdown reports plus a digest.
+
+**Non-goals (v0.1):** repo-scoped coding jobs, Linux/Windows support, priorities/dependencies between jobs, any server component.
+
+## Architecture
+
+Three pieces, one data directory (`~/.overnight`):
+
+1. **CLI (`overnight`)** — queue management (`add/list/remove`), visibility (`status`), execution (`run`), setup (`install/uninstall`). Pure-stdlib Python 3.11+.
+2. **`/queue` slash command + Claude Code plugin** — thin wrappers that shell out to `overnight add`, so queueing never requires leaving a session.
+3. **Runner + launchd agent** — a 30-minute tick; each tick is idempotent and cheap when there's nothing to do (no queue, outside window, limits hot, or another runner holds the lock).
+
+Module boundaries (`src/overnight/`):
+
+| Module | Responsibility | Depends on |
+| --- | --- | --- |
+| `paths` | filesystem layout, `OVERNIGHT_HOME` override | — |
+| `config` | TOML config, window math | `paths` |
+| `store` | job persistence (one JSON per job), status transitions | `paths` |
+| `limits` | OAuth token discovery, usage endpoint, defensive parsing | — |
+| `runner` | start/continue decisions, job execution, results, index, lock | all above |
+| `notify` | best-effort macOS notification | — |
+| `install` | launchd plist, slash command file | `paths` |
+| `cli` | argument parsing only | all above |
+
+## Key decisions
+
+- **Decisions are pure functions** (`should_start`, `should_continue`) taking config + usage + clock, so the threshold logic is unit-testable without network or subprocesses.
+- **Usage unknown ≠ usage zero.** `fetch_usage()` returns `None` on any failure and callers proceed optimistically, relying on limit-error detection in `claude -p` output. This is what keeps the tool alive if the undocumented endpoint changes.
+- **Limit-hit jobs are requeued, not failed.** A job that ran into the cap did nothing wrong; it runs next window. The batch stops immediately.
+- **One JSON file per job** instead of a single queue file: no read-modify-write races between `add` (interactive) and the runner; the runner's lockfile only guards batch execution.
+- **Jobs run in a scratch cwd with tools restricted to `WebSearch,WebFetch`** — an unattended agent gets no access to the user's projects.
+
+## Testing
+
+32+ unit tests cover: store roundtrips, config parsing and midnight-crossing windows, both usage payload shapes (modern `limits` list, legacy `five_hour`/`seven_day`), start/continue threshold decisions, job success/failure/timeout/limit-requeue paths, batch behavior (index writing, mid-batch limit stop, lock contention, attempt exhaustion). The `claude` subprocess and the usage endpoint are mocked; `OVERNIGHT_HOME` isolates all filesystem state per test.

claude_overnight-0.1.0/docs/how-it-works.md

@@ -0,0 +1,72 @@
+# How it works
+
+There is no official API for Claude Code subscription limits. This document explains what `claude-overnight` does instead, so you can judge the tradeoffs yourself.
+
+## Reading your limits
+
+Claude Code authenticates Pro/Max subscriptions with an OAuth token it stores locally:
+
+- **macOS Keychain**, service `Claude Code-credentials` (the default on Macs)
+- `~/.claude/.credentials.json` (Linux, and some macOS setups)
+
+The community discovered that this token works against an undocumented endpoint:
+
+```
+GET https://api.anthropic.com/api/oauth/usage
+Authorization: Bearer <accessToken>
+anthropic-beta: oauth-2025-04-20
+```
+
+The response contains a `limits` list with entries like:
+
+```json
+{ "kind": "session",       "percent": 27.5, "resets_at": "2026-07-15T09:29:59Z" }
+{ "kind": "weekly_scoped", "percent": 44,   "resets_at": "2026-07-18T18:59:59Z",
+  "scope": { "model": { "display_name": "Fable" } } }
+```
+
+- `session` is the rolling **5-hour window**.
+- `weekly_scoped` entries are the **weekly limits**, potentially one per model. `claude-overnight` conservatively uses the highest active one.
+
+Older accounts return a legacy shape (`five_hour` / `seven_day` objects with a `utilization` field); the parser handles both.
+
+The token is **read at runtime and never stored, logged, or sent anywhere except `api.anthropic.com`** — the same place Claude Code itself sends it.
+
+## Deciding when to run
+
+A launchd agent ticks every 30 minutes. On each tick the runner checks, in order:
+
+1. **Lockfile** — is another batch already running? (Stale locks older than 2 hours are cleared.)
+2. **Night window** — is the local time inside `[window.start, window.end)`? Windows may cross midnight.
+3. **Weekly cap** — is weekly utilization ≤ `weekly_max_utilization`? If your week is nearly spent, running overnight jobs would eat quota you'll want for real work.
+4. **5-hour start cap** — is the 5-hour window ≤ `start_max_utilization`? A fresh window means the batch gets maximum room.
+
+Between every job it re-checks, and stops once the 5-hour window crosses `stop_utilization` — the whole point is to use *surplus* quota, not to hand you an empty tank at 9am.
+
+## Running jobs
+
+Each job runs through Claude Code's headless mode:
+
+```
+claude -p "<wrapped prompt>" --output-format json --model sonnet --allowedTools "WebSearch,WebFetch"
+```
+
+- The wrapper instructs Claude that it is unattended: make reasonable assumptions, state them, and produce a self-contained markdown report with sources.
+- Tools are restricted to web search/fetch; jobs run in an empty scratch directory, so they can't touch your projects.
+- Each job has a timeout (default 15 minutes) and a max attempt count (default 2).
+
+## Failure modes, by design
+
+| What breaks | What happens |
+| --- | --- |
+| Usage endpoint changes or disappears | `fetch_usage()` returns `None`; the runner proceeds optimistically and relies on error detection instead |
+| Token expired (Claude Code hasn't run in a while) | Same as above — and `claude -p` refreshes tokens itself when it runs |
+| A job hits the usage limit mid-batch | The job is **requeued untouched**, the batch stops, and the next tick (or next night) retries |
+| Mac asleep during the window | launchd runs the missed tick on wake |
+| `claude` CLI missing | Job marked failed with a clear error |
+| Two ticks overlap | Lockfile prevents the second runner |
+
+## What this is not
+
+- It does not bypass, extend, or game your limits — it only runs work you queued, on your own subscription, at times your quota would otherwise sit idle.
+- It is not affiliated with Anthropic, and the usage endpoint could change without notice. The tool is built to degrade to "try and detect" rather than break.

claude_overnight-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[project]
+name = "claude-overnight"
+version = "0.1.0"
+description = "Queue research questions all day. Wake up to answers. Puts your idle Claude Code quota to work while you sleep."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "Rohan Richard" }]
+keywords = ["claude", "claude-code", "queue", "rate-limits", "automation"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: MacOS",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Build Tools",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/rohanprichard/claude-overnight"
+Issues = "https://github.com/rohanprichard/claude-overnight/issues"
+
+[project.scripts]
+overnight = "overnight.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/overnight"]
+
+[dependency-groups]
+dev = ["pytest>=8"]

claude_overnight-0.1.0/src/overnight/__init__.py

@@ -0,0 +1,3 @@
+"""claude-overnight: queue research questions, run them when your Claude quota resets."""
+
+__version__ = "0.1.0"