<p align="center"><img src="assets/brand/auto-invent-logo.png" alt="auto:Invent" width="360"></p>

**auto:Invent** plans your AWS re:Invent 2026 week around the Las Vegas Strip, then keeps the plan working while you're there.

Tell it who you are (paste a resume or a few lines) and the sessions you can't miss. It builds a day-by-day plan that holds up on foot, by shuttle and by monorail:

- **Travel is part of the plan.** Every walk, shuttle, monorail ride or (only when truly necessary) cab is its own block, with a leave-by time.
- **A Plan B for every slot.** Each planned session has backups that fit the same slot: a repeat of the session, a walk-up session, or something relevant nearby.
- **Live mode on your phone.** "What now?", "I'm running 20 min late" and "it's full" each re-solve the rest of your day from where you are.
- **It writes back to your official re:Invent schedule.** Sessions become favorites and travel becomes personal time, so the plan shows up in the re:Invent app.

Built for the re:Invent Catalog API Builder Challenge on the [AWS Events API and MCP server](https://docs.aws.amazon.com/events/latest/devguide/what-is-events-api.html).

---

## Try it in two minutes (no accounts needed)

```bash
git clone https://github.com/dafrost22/auto-invent.git && cd auto-invent
npm install
npm run demo
```

This opens `http://localhost:8485` in **demo mode**: dummy data, no sign-in, no AWS credentials. The data is invented but shaped like the real catalog. A banner stays on screen saying it isn't the real re:Invent catalog. Pick one of the fictional attendees and press **Build my week**.

## Use it for real

You need:

- **Node.js 24 LTS** (see `.nvmrc`). Node 22 or newer works.
- **An AWS Builder ID registered for re:Invent 2026.** The re:Invent catalog in the API is only readable by registered attendees.
- **Optional: AWS credentials with Amazon Bedrock model access** (your default profile, or `AWS_PROFILE`). With them, the **auto:Invent concierge** turns on. It's built on the [Strands Agents SDK](https://strandsagents.com) with Claude on Bedrock: it reads your background, reranks your top sessions, and handles plain-language requests. Without them, planning still works using the catalog's own tags, and the command bar understands the common commands.

```bash
npm install
npm start
```

`npm start` builds the web app, starts the local app on `http://localhost:8485` and opens it. Sign in with your Builder ID. The sign-in happens on your own computer, and your tokens never leave it. They are sent only to `oauth.awsevents.com` and `api.awsevents.com`, and stored in `~/.auto-invent/` readable only by you.

| Command | What it does |
|---|---|
| `npm run demo` | Local app on dummy data. No sign-in, no AWS. |
| `npm start` | Local app on the real re:Invent 2026 catalog |
| `npm test` | Unit tests (planner, travel, time zones, sync, commands, demo data guardrails) |
| `npm run typecheck` | Type-check every package |
| `npm run codegen` | Regenerate API types from `docs/events-api/openapi.json` |
| `npm run fixture:demo` | Rebuild the demo data (see [Demo data](#demo-data)) |

**Environment variables** (all optional):

| Variable | Purpose |
|---|---|
| `AWS_PROFILE`, `AWS_REGION` | Which AWS credentials and region to use for Bedrock. Region defaults to `us-east-1`. |
| `AUTO_INVENT_BEDROCK_MODEL`, `AUTO_INVENT_BEDROCK_FAST_MODEL` | Pin Bedrock model or inference-profile ids. By default the newest enabled Claude Sonnet and Haiku are discovered. |
| `AUTO_INVENT_NO_LLM=1` | Turn AI planning off |
| `AUTO_INVENT_HOME` | Where local state lives. Default `~/.auto-invent`. |
| `VITE_AMAZON_LOCATION_KEY`, `VITE_AMAZON_LOCATION_REGION` | Amazon Location Service API key for the basemap. You can also paste one in Settings. |

The app listens only on `127.0.0.1`, and on one of the Builder ID sign-in ports (8485–8489, then 8484).

## What it does

**Plan the week**
- **Who you are.** Your resume or a short description becomes a profile of services, topics, level and goals. It uses Claude on Bedrock if available, otherwise keyword matching against the catalog. Only the derived profile is kept. You can optionally add services from your own AWS usage (Cost Explorer, read-only; the data stays on your machine).
- **Must-sees are anchors.** They are placed first. If two clash, auto:Invent tries their other times before asking you. It never drops one silently.
- **Scheduling.** Ranking and feasibility are separate. The profile decides what matters. A deterministic solver decides what fits, given travel time between venues, arrive-early buffers, lunch, your daily cap, your walking tolerance and repeats (the same session is never scheduled twice).
- **Favors what isn't recorded.** Chalk talks, workshops and builders' sessions are usually not recorded, so they rank higher for in-person time. Recorded sessions that don't fit go on a Watch later list.
- **Official program.** Keynotes can be streamed from wherever you are or attended in person. "Going to re:Play" adds Thursday night, with the trip there and back to your hotel. Badge pickup, the Expo and the receptions are in the logistics data.

**Get around**
- **Transport** comes from the official campus: the 6 session venues and 14 campus hotels, numbered as on the official map.
  - Walking includes the indoor routes: Venetian to Caesars Forum by skybridge, Venetian to Wynn and Encore.
  - re:Invent shuttles run between venues that are too far to walk, and to re:Play. They don't serve rooms-only hotels.
  - The Las Vegas Monorail is free with your badge. Its hours are modeled, so it knows the monorail closes at midnight on Monday.
  - The Deuce bus runs 24/7.
  - A cab is suggested only when truly necessary, and it always says why.
- **Map.** Your route over a real street map, with the campus overlay and transit lines. Walking distance and steps per day.

**Live the week**
- **Now / Next** shows a departure-board view with the leave-by countdown, and a Plan B for the next slot.
- **Commands** you can type:
  - "add dinner at Wynn 7pm Tue"
  - "I'm running 20 min late"
  - "it's full"
  - "what now?"
  - "find 30 min for a meeting Wed afternoon"
  - "swap anything under 200-level"
  - "more hands-on"
  - "less walking"
  - "going to re:Play"

  Every change is shown as a diff before it's applied.
- **Seat watcher.** It watches seats on your Plan B and wish-listed sessions. When a seat opens you get **one-tap reserve**. auto:Invent never reserves anything automatically.
- **Catalog changes.** Each refresh records which sessions were added or removed, and a refresh that suddenly loses most of the catalog (an API hiccup) is refused instead of wiping your plan.

**Ask the concierge (with Bedrock)**
- **Plain-language requests.** For example "I have a customer dinner at Wynn at 7 on Tuesday", "what should I do now?", or "I'd rather not walk after dark". The concierge is a Strands agent with auto:Invent's planner tools and the official Events MCP server's tools.
  - It reads your official schedule through MCP.
  - Before any MCP write (a favorite, a personal-time block) it pauses and asks you to approve, using Strands' human-in-the-loop interrupts.
  - Changes to the plan itself come back as proposals you review.
  - It can't reserve seats; it can offer you a one-tap Reserve button.
- **Local memory.** It remembers what matters about you on your computer: preferences you mention, people you want to meet, sessions you attended or skipped, changes you made. It uses the Strands memory manager with a file-based store, as plain markdown in `~/.auto-invent/strands/`. Settings → "What auto:Invent remembers" shows every entry and lets you forget any of them. Your conversation also persists across restarts.

**Share and wrap up**
- **Sync to your official schedule.** Sessions become favorites; travel, meetings and meals become personal time. Only entries auto:Invent created are ever changed.
- **Calendar export.** `.ics` export for your normal calendar.
- **Plan files for teams.** Split sessions between colleagues without doubling up, and find times you're both free and nearby. Plan files contain only ids, times and places.
- **Check-offs and notes.** Mark sessions attended, keep notes, get a recap post draft and a shareable "my week" card.
- **Works offline.** It's an installable PWA with cached map tiles for bad casino signal.

## How it uses the Events API and MCP server

| Operation | Used for |
|---|---|
| `ListEvents`, `GetEvent` | Event metadata: dates, timezone, time format, supported languages |
| `ListSessions` (all pages, per locale) | The full catalog, cached locally. The API has no search, so filtering happens in the app. |
| `GetSession` | Seat watcher: `seatAvailability` on watched sessions, within quota |
| `GetSchedule` | Your reservations become locked items; favorites and personal time are read for sync (through the MCP server first) |
| `AssociateFavorites`, `DisassociateFavorite` | Sync: planned sessions become favorites; ones auto:Invent added and you later dropped are removed (MCP first) |
| `CreatePersonalTime`, `DeletePersonalTime` | Sync: travel legs with leave-by times, meetings and meals; commitments are written the moment you apply them (MCP first) |
| `ReserveSessions`, `CancelReservation` | One-tap reserve and cancel, only when you tap. Per-session results are shown. |
| MCP server (`https://api.awsevents.com/mcp`) | **The main path for your schedule.** Every schedule read and write goes through the MCP tools with your Builder ID token, and falls back to REST per operation only if a call can't go through (for example, if a tool's schema doesn't match). The Strands concierge uses the same server: it reads freely, and each write (favorites, personal time) pauses for your approval. Settings shows which operations went through which surface. |

auto:Invent also **is** an MCP server. It exposes its planner as tools you can use from Claude Code or Kiro alongside the official `awsevents` server: `plan_day`, `what_now`, `plan_b`, `travel_time`, `find_meeting_slot`, `explain_session` and `list_places`.

```bash
# Claude Code (stdio). Uses the local app's cache, sign-in and saved plan.
claude mcp add --scope user auto-invent -- node /path/to/auto-invent/apps/local/bin/auto-invent.mjs mcp
# Add --demo at the end to use the demo data.
```

## Architecture

auto:Invent is a **local web app you run yourself**. The Events API's sign-in only redirects to a loopback address, and there is no hosted option. Nobody else's tokens, schedules or catalog data ever pass through a server we run.

```
apps/local      Node local app: serves the UI, Builder ID sign-in (PKCE), Events REST + MCP clients,
                catalog cache, seat watcher, the auto:Invent MCP server, and the Strands Agents
                concierge with local memory (optional, needs Bedrock)
apps/web        React + Vite UI, installable PWA; also builds as a static demo
packages/core   Isomorphic TypeScript: API types and client, time zones, campus and transit model,
                scoring, solver, Plan B, live replanning, sync, calendar export, command parser
data/           Campus, transit and logistics data (with provenance), session formats
fixtures/demo   Dummy catalog and fictional attendees for demo mode
scripts/        Demo-data generator and anonymizer, OpenStreetMap fetch, path builder
```

More detail in [docs/architecture.md](docs/architecture.md).

## Data and provenance

The Events API gives a venue *name* for each session, and nothing about maps, hotels or transit. That logistics layer is auto:Invent's own. Every fact records where it came from, and anything unofficial is marked in the app and can be overridden in Settings.

- **Campus.** The venues, hotels and numbering come from the official re:Invent 2026 campus map. Footprints and entrances come from OpenStreetMap.
- **Transit.** The monorail and Deuce geometry come from OpenStreetMap. Monorail hours come from lvmonorail.com. Free monorail rides with your badge and the shuttle policy come from the re:Invent FAQ and the venues page.
- **Walking and driving paths.** `data/paths.json` holds real routes between campus places along sidewalks, footbridges and roads, computed from OpenStreetMap with the FOSSGIS OSRM servers by `scripts/geodata/build-paths.mjs`. The planner times walks by their routed length, and the map draws every leg along them. Casino interiors aren't mapped, so the indoor connections (Venetian, Wynn, Encore, Caesars Forum) keep their measured walking times.
- **Program.** Badge pickup, keynotes, Expo, receptions and re:Play come from the official re:Invent agenda.
- **Meals.** Meal times and places are prior-year patterns until AWS publishes 2026 details.

Map, transit and path data in `data/campus.geo.json`, `data/transit/` and `data/paths.json` is **© OpenStreetMap contributors, available under the [ODbL](https://opendatacommons.org/licenses/odbl/)**.

### Demo data

The real re:Invent catalog is only available to registered attendees, so it's never committed or published. Demo mode uses `fixtures/demo/`, generated by `scripts/build-demo-fixture.ts`:

- **Keeps the shape.** Venues, time slots, formats, levels, tag mix and how often sessions repeat.
- **Replaces all content.** Titles, abstracts, speakers, codes and exact times are invented.
- **Guardrail.** The generator refuses to write if any real title, sentence, speaker or code would leak into the output.

## Privacy and safety

- **Tokens stay local.** Your Builder ID tokens stay on your machine and are only ever sent to AWS's sign-in and Events API endpoints.
- **Only derived data is stored.** Your resume text isn't stored, only the derived profile. AI calls go to Bedrock in *your* AWS account.
- **Memory stays on your computer** as plain files you can read and delete. Every change the concierge makes to your official schedule needs your approval first. It has no tool that can reserve or cancel a seat, and a hook blocks any attempt.
- **Reservations are one-tap only.** They are never automatic. The seat watcher only notifies you.
- **Quotas are respected.** The catalog is cached, seat checks are paced, and `Retry-After` is honored on throttling.

## Development

```bash
npm test          # vitest
npm run typecheck
npm run dev       # local app with reload; run `npm run dev:web` for the Vite dev server (proxies /api)
```

The optional cloud deploy (`npm run deploy`, a CloudFormation stack in your own AWS account for phone access and an always-on seat watcher) is in progress.

## License

The code is released under the [MIT License](LICENSE). The map, transit and path data derived from OpenStreetMap (`data/campus.geo.json`, `data/transit/`, `data/paths.json`) is © OpenStreetMap contributors and available under the [ODbL](https://opendatacommons.org/licenses/odbl/).