dineway 0.1.30 → 0.1.32

package/README.md

@@ -1,190 +1,215 @@
-# Dineway
+# Dineway — Build Your Restaurant Website with AI
 
-The Agentic Website builder for restaurants and local businesses. Dineway combines structured content modeling with the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) to create intelligent, AI-powered sites that don't just display information — they understand your menus, manage your reputation, execute marketing, and act on behalf of the restaurant owner.
+Dineway is the **Agentic Website builder** for restaurants and local businesses. You don't need to write code. Just tell an AI agent your restaurant name and city, and it builds a professional website — with menus, blog, reviews, gallery, and local SEO — automatically.
 
-The core thesis: A restaurant's website should not be a brochure. It should be an employee — they understand it, act on it, and improve autonomously.
+> **How it works:** You paste this guide into an AI agent (Codex, Claude, OpenClaw, or similar). The agent reads it, installs the tools, and builds your site end-to-end. You review, approve, and publish.
 
-## Overview
+---
 
-Dineway is an [Astro](https://astro.build) integration that gives your site a full content engine, admin panel, built-in MCP server, and plugin system. It runs on Node.js with SQLite/libSQL (or PostgreSQL), deploys anywhere with a single command, and stores all schema in the database — not in code.
+## What You Get
 
-### Architecture
+| Feature | Description |
+| --- | --- |
+| 🍽️ **Restaurant Website** | A polished, mobile-first site built from your real business data — hours, location, reviews, photos |
+| 📝 **Blog & News** | Articles derived from real customer reviews and restaurant updates |
+| 🍕 **Menu Display** | Structured menu with items, prices, descriptions, and photos |
+| ⭐ **Reviews Showcase** | Curated real reviews that highlight your restaurant's character |
+| 🖼️ **Photo Gallery** | A CMS-managed gallery with your best images |
+| 🔍 **Local SEO** | JSON-LD structured data, meta tags, and local business schema — all automatic |
+| 🛠️ **Admin Panel** | A visual dashboard to edit content, manage media, and publish changes |
+| 🤖 **AI-Powered** | 50+ MCP tools let AI agents manage content, menus, and marketing on your behalf |
 
-```
-┌──────────────────────────────────────────────────────────────────┐
-│                       Your Restaurant Site                       │
-│                                                                  │
-│   Astro Framework (Live Collections · Sessions · Middleware)     │
-│                                                                  │
-│  ┌────────────┐  ┌────────────┐  ┌────────────┐  ┌───────────┐  │
-│  │  Content   │  │   Admin    │  │    MCP     │  │  Plugins  │  │
-│  │  Engine    │  │   Panel    │  │   Server   │  │           │  │
-│  └────────────┘  └────────────┘  └────────────┘  └───────────┘  │
-│  ┌────────────┐  ┌────────────┐  ┌────────────┐  ┌───────────┐  │
-│  │ Site       │  │  Entity    │  │   HITL     │  │   CLI     │  │
-│  │ Context    │  │ Resolution │  │  Reviews   │  │           │  │
-│  └────────────┘  └────────────┘  └────────────┘  └───────────┘  │
-│                                                                  │
-│  Data Layer: SQLite / libSQL / PostgreSQL ←→ Local / S3 Storage  │
-└──────────────────────────────────────────────────────────────────┘
-```
+---
 
-### Core Capabilities
+## Before You Start
 
-| Category                | What It Does                                                                                                 |
-| ----------------------- | ------------------------------------------------------------------------------------------------------------ |
-| **MCP Server**          | 50+ tools for AI agents to interact with content, schema, media, search, taxonomies, menus, and site context |
-| **Site Context Engine** | Versioned operational knowledge (brand voice, seasonal strategy, policies) — agents consult before acting    |
-| **Content Engine**      | Structured collections with typed fields, revisions, drafts, scheduled publishing, and full-text search      |
-| **Entity Resolution**   | Natural-language references ("the spring lamb special") resolve to exact content items                       |
-| **Human-in-the-Loop**   | Review requests ensure AI-generated changes get human approval before going live                             |
-| **Admin Panel**         | Visual schema builder, rich text editor (TipTap/Portable Text), media library, menu builder                  |
-| **Plugin System**       | Lifecycle hooks, KV storage, settings, admin pages, dashboard widgets, custom block types                    |
-| **CLI**                 | Programmatic site management for content, schema, media, deployment — designed for both humans and AI agents |
+### What You Need
 
-## Installation
+1. **Node.js 22 or later** — [download here](https://nodejs.org/)
+2. **An AI agent environment** — any of these:
+   - [OpenAI Codex](https://openai.com/codex)
+   - [Claude Code](https://claude.ai)
+   - [OpenClaw](https://openclaw.dev)
+   - Any agent that supports skill packs
+3. **Your restaurant info** — name and city (that's it!)
 
-```shell
-npm create dineway@latest
-```
+### Check Node.js
 
-Or add to an existing Astro project:
+Open a terminal and run:
 
-```shell
-npm install dineway
+```bash
+node --version
+# Should print v22.x.x or higher
 ```
 
-## Agent Skills
+If you don't have Node.js, download it from [nodejs.org](https://nodejs.org/) and install it first.
 
-Dineway also publishes an agent skill pack for designing, building, and publishing AI-ready restaurant sites. The skills guide agents through place-data enrichment, restaurant information architecture, visual design, Dineway CMS schema and seed content, media upload, local SEO, and deployment.
+---
 
-Install the skill pack with `npx skills`:
+## Step 1 — Install Dineway Skills
+
+Dineway Skills are instruction packs that teach your AI agent how to build restaurant websites. Install them with one command:
 
 ```bash
 npx skills add https://github.com/dineway/dineway-skills
 ```
 
-For a full restaurant build, invoke the restaurant-site skill with a restaurant name and city:
+This installs the following skills into your project:
 
-```text
-Use building-restaurant-site to build an AI-ready Dineway restaurant site for "Restaurant Name" in "City, Country".
-```
+| Skill | What It Does |
+| --- | --- |
+| `building-restaurant-site` | End-to-end restaurant site creation from real place data |
+| `building-dineway-site` | General Dineway site building patterns |
+| `dineway-cli` | CLI commands for managing content, schema, media, and deployment |
+| `enrich-place-details` | Fetches your restaurant's real data (hours, reviews, photos, location) |
+| `frontend-design` | Creates distinctive, production-grade visual design |
+| `brainstorming` | Explores design and architecture options before building |
 
-For an existing Dineway project, use the CLI skill to manage schema, content, media, generated types, and deployment:
+---
 
-```text
-Use dineway-cli to seed content, generate types, upload media, and deploy this Dineway site.
-```
+## Step 2 — Create Your Restaurant Site
+
+### Option A: Tell the Agent (Recommended)
 
-## CLI
+Paste this into your AI agent's input:
 
-The Dineway CLI (`dineway`) manages projects and instances. Commands fall into three categories:
+```text
+Use building-restaurant-site to build an AI-ready Dineway restaurant site for "YOUR RESTAURANT NAME" in "YOUR CITY, COUNTRY".
+```
 
-- **Local commands** — work directly on local project files or a SQLite file, no running server needed: `init`, `dev`, `seed`, `export-seed`, `auth secret`, `secrets generate`, `secrets fingerprint`
-- **Deployment commands** — orchestrate platform CLIs or generate provider files: `deploy`
-- **Remote commands** — talk to a running Dineway instance via HTTP: `types`, `login`, `logout`, `whoami`, `content`, `schema`, `media`, `search`, `taxonomy`, `menu`
+Replace with your real restaurant name and city. Examples:
 
-### Authentication
+```text
+Use building-restaurant-site to build an AI-ready Dineway restaurant site for "Peace Harmony" in "Sydney, Australia".
+```
 
-Remote commands resolve auth automatically in this order:
+```text
+Use building-restaurant-site to build an AI-ready Dineway restaurant site for "La Maison Rouge" in "Paris, France".
+```
 
-1. `--token` flag
-2. `DINEWAY_TOKEN` env var
-3. Stored credentials from `dineway login`
-4. Dev bypass (localhost only — no token needed)
+The agent will automatically:
 
-For local dev servers, just run the command — auth is handled automatically. For remote instances, run `dineway login --url https://my-site.example.com` first.
+1. Search for your restaurant and fetch real business data (hours, reviews, photos, location)
+2. Download and curate the best photos
+3. Design an information architecture with Blog, News, Menu, Reviews, and Gallery
+4. Build a polished Astro website with local SEO and JSON-LD
+5. Create the Dineway CMS schema and seed content
+6. Start a local dev server for you to preview
 
-## Quick Start
+### Option B: Manual Project Creation
 
-### Create and Run
+If you prefer to start with a blank project and build it yourself:
 
 ```bash
-# Create a new Dineway site
+# Create a new Dineway project
 npm create dineway@latest my-restaurant
+
+# Enter the project directory
 cd my-restaurant
+
+# Install dependencies
 npm install
 
-# Start the dev server (runs migrations automatically)
+# Start the dev server
 npx dineway dev
-
-# Open the admin panel at http://localhost:4321/_dineway/admin
-# Complete the Setup Wizard to create your first admin account
 ```
 
-### Seed a Site
+The dev server starts at `http://localhost:4321`. The admin panel is at `http://localhost:4321/_dineway/admin`.
+
+---
+
+## Step 3 — Preview Your Site
+
+Once the agent finishes building (or you've started the dev server manually), open your browser:
+
+- **Your site:** `http://localhost:4321`
+- **Admin panel:** `http://localhost:4321/_dineway/admin`
+
+On your first visit to the admin panel, the Setup Wizard runs automatically — it creates the database and prompts you to create your admin account.
+
+### Create Your Admin Account
 
-Apply a seed file to bootstrap collections, menus, taxonomies, and content:
+1. Open `http://localhost:4321/_dineway/admin`
+2. The Setup Wizard appears on first visit
+3. Enter your email and display name
+4. Register a passkey (fingerprint, Face ID, or security key)
+5. You're now the site administrator
+
+> **Tip:** In dev mode, you can skip passkey setup by visiting:
+> `http://localhost:4321/_dineway/api/setup/dev-bypass?redirect=/_dineway/admin`
+
+---
+
+## Step 4 — Manage Content with Dineway CLI
+
+The Dineway CLI is your command-line tool for managing everything about your site. The AI agent uses it automatically, but you can also use it directly.
+
+### Seed Your Site with Content
+
+If you have a seed file (the agent creates one automatically):
 
 ```bash
-npx dineway seed .dineway/seed.json
+npx dineway seed seed/seed.json
 ```
 
-Export the current database as a reusable seed:
+### Manage Menu Items
 
 ```bash
-npx dineway export-seed > seed.json
-npx dineway export-seed --with-content > seed-with-content.json
+# List all menu items
+npx dineway content list menu-items
+
+# Add a new menu item
+npx dineway content create menu-items --data '{
+  "title": "Grilled Salmon",
+  "description": "Atlantic salmon with seasonal vegetables",
+  "price": 28.50
+}'
+
+# Update a menu item (use the ID from a prior list/get)
+npx dineway content get menu-items grilled-salmon
+npx dineway content update menu-items 01ABC123 --rev MToyMDI2... --data '{"price": 32.00}'
 ```
 
-### Manage Content via CLI
-
-The CLI is designed for both humans and AI agents. Create and update auto-publish by default for immediate read-after-write consistency.
+### Manage Blog Posts
 
 ```bash
-# List content
+# List posts
 npx dineway content list posts
-npx dineway content list posts --status published --limit 10
 
-# Get a single item (Portable Text fields converted to markdown)
-npx dineway content get posts my-post-slug
+# Create a new blog post
+npx dineway content create posts --data '{
+  "title": "Spring Menu Now Available",
+  "content": "# Fresh Flavors for the Season\n\nWe are excited to announce our new spring menu..."
+}'
+```
 
-# Create content (auto-publishes by default)
-npx dineway content create posts --data '{"title": "Spring Menu", "content": "# New Dishes"}'
-npx dineway content create posts --file post.json --slug spring-menu
+### Upload Photos
 
-# Update content (requires --rev from a prior get)
-npx dineway content update posts 01ABC123 --rev MToyMDI2... --data '{"title": "Updated"}'
+```bash
+# Upload a dish photo
+npx dineway media upload ./dish-photo.jpg --alt "Grilled salmon plate" --caption "Our signature dish"
 
-# Lifecycle
-npx dineway content publish posts 01ABC123
-npx dineway content unpublish posts 01ABC123
-npx dineway content schedule posts 01ABC123 --at 2026-03-01T09:00:00Z
+# List all media
+npx dineway media list
 ```
 
-### Manage Schema
+### Manage Schema (Collections & Fields)
 
 ```bash
-# List collections
+# List all collections
 npx dineway schema list
 
-# Create a collection
-npx dineway schema create menu-items --label "Menu Items"
+# Add a field to menu items
+npx dineway schema add-field menu-items calories --type integer --label "Calories"
 
-# Add fields
-npx dineway schema add-field menu-items price --type number --required
-npx dineway schema add-field menu-items description --type text --label "Description"
-npx dineway schema add-field menu-items photo --type image
+# Create a new collection
+npx dineway schema create specials --label "Daily Specials"
 ```
 
-Field types: `string`, `text`, `number`, `integer`, `boolean`, `datetime`, `image`, `reference`, `portableText`, `json`.
-
-### Media, Search, Taxonomies, and Menus
+### Search Content
 
 ```bash
-# Upload media
-npx dineway media upload ./dish-photo.jpg --alt "Grilled lamb" --caption "Spring special"
-
-# Search content
-npx dineway search "lamb" --collection menu-items --limit 5
-
-# Manage taxonomies
-npx dineway taxonomy list
-npx dineway taxonomy add-term categories --name "Seasonal" --slug seasonal
-
-# View menus
-npx dineway menu list
-npx dineway menu get primary
+npx dineway search "salmon" --collection menu-items
 ```
 
 ### Generate TypeScript Types
@@ -193,95 +218,272 @@ npx dineway menu get primary
 npx dineway types
 ```
 
-Writes `.dineway/types.ts` and `.dineway/schema.json` for full type safety in your Astro pages.
+> **For agents:** All CLI commands support `--json` for machine-readable output. It's auto-enabled when stdout is piped:
+> ```bash
+> npx dineway content list posts --json | jq '.items[].slug'
+> ```
+
+---
 
-### Deploy
+## Step 5 — Deploy Your Site & Own Your Website
 
-One-command deployment to any Node.js host:
+Unlike standard SaaS website builders, Dineway lets you fully own your website. Your code, your structured menus, your blog posts, and your media files belong entirely to you. You can choose to deploy to Dineway's official platform or host it on your own server or cloud provider with zero vendor lock-in.
+
+### Option A: Deploy to Forgeway (Simplest & Managed)
+
+Forgeway is Dineway's first-party hosting platform. It's the easiest way to go live:
 
 ```bash
-npx dineway@latest deploy            # default deploy to dineway platform (no setup required)
-npx dineway@latest deploy railway    # generates railway.json, runs railway up
-npx dineway@latest deploy docker     # generates Dockerfile + .dockerignore
-npx dineway@latest deploy fly        # generates Fly config, runs fly deploy
-npx dineway@latest deploy gcp        # experimental: gcloud run deploy
+npx dineway deploy forgeway
 ```
 
-### JSON Output
+What happens:
+1. You verify your email address (Dineway account).
+2. The site is built, global CDN is configured, and database is provisioned.
+3. You receive a **one-time setup link** to register your admin passkey on the live site.
+4. `DINEWAY_SITE_URL` and `DINEWAY_TOKEN` are saved to your project `.env` automatically so remote CLI commands work out of the box.
+
+> **Important:** Open the setup link in your browser immediately. It lets you register your secure passkey for the live admin panel. If you lose or expire the link, regenerate it with `npx dineway auth setup-link`.
 
-All CLI commands support `--json` for machine-readable output. Auto-enabled when stdout is piped:
+---
+
+### Option B: Self-Host Anywhere (Maximum Ownership)
+
+You can host Dineway on your own infrastructure. Dineway runs as a standard Node.js server.
 
 ```bash
-npx dineway content list posts --json | jq '.items[].slug'
-ID=$(npx dineway content create posts --data '{"title":"Hello"}' --json | jq -r '.id')
+# Choose a platform target to generate configurations and deploy
+npx dineway deploy railway    # Generates railway.json & deploys to Railway
+npx dineway deploy fly        # Generates fly.toml & deploys to Fly.io with persistent volumes
+npx dineway deploy docker     # Generates Dockerfile & .dockerignore
+npx dineway deploy docker --compose  # Generates Dockerfile + docker-compose.yml for local VPS hosting
+npx dineway deploy gcp        # Google Cloud Run (experimental)
 ```
 
-## Astro Configuration
-
-```typescript
-// astro.config.mjs
-import { defineConfig } from "astro/config";
-import dineway, { local } from "dineway/astro";
-import { sqlite } from "dineway/db";
-
-export default defineConfig({
-	integrations: [
-		dineway({
-			database: sqlite({ url: "file:./data.db" }),
-			storage: local({
-				directory: "./uploads",
-				baseUrl: "/_dineway/api/media/file",
-			}),
-		}),
-	],
-});
+#### Configuring Your Database & Media Storage for Self-Hosting
+
+When self-hosting, you specify how the database and media files are stored in `astro.config.mjs` using environment variables or configuration blocks:
+
+1. **Database Options**:
+   - **Local SQLite (Standard)**: Best for single-container VPS or Fly.io with a persistent volume.
+     ```typescript
+     database: sqlite({ url: "file:./data/data.db" })
+     ```
+   - **Remote libSQL (Turso)**: Excellent for serverless or ephemeral platforms like Railway, Fly, or GCP.
+     ```typescript
+     database: libsql({
+       url: process.env.DINEWAY_DATABASE_URL || "libsql://...",
+       authToken: process.env.DINEWAY_DATABASE_TOKEN
+     })
+     ```
+   - **PostgreSQL**: Industry-standard relational database.
+     ```typescript
+     database: postgres({ connectionString: process.env.DATABASE_URL })
+     ```
+
+2. **Media Storage Options**:
+   - **Local Uploads**: Saves images directly on the server's hard disk (ideal for local VPS).
+     ```typescript
+     storage: local({ directory: "./uploads", baseUrl: "/_dineway/api/media/file" })
+     ```
+   - **S3-Compatible Storage (AWS S3, Cloudflare R2, MinIO)**: Best for ephemeral hosts (Railway, Cloud Run) so files are never lost when the container restarts.
+     ```typescript
+     storage: s3({
+       bucket: process.env.S3_BUCKET_NAME,
+       region: process.env.S3_REGION,
+       endpoint: process.env.S3_ENDPOINT, // e.g. Cloudflare R2 or MinIO endpoint
+       accessKeyId: process.env.S3_ACCESS_KEY_ID,
+       secretAccessKey: process.env.S3_SECRET_ACCESS_KEY
+     })
+     ```
+
+### After Deployment
+
+Once deployed, manage your live site remotely:
+
+```bash
+# Log in to your live site
+npx dineway login --url https://your-site.example.com
+
+# Check who you're logged in as
+npx dineway whoami
+
+# Manage content remotely
+npx dineway content list posts --url https://your-site.example.com
 ```
 
-```typescript
-// src/live.config.ts
-import { defineLiveCollection } from "astro:content";
-import { dinewayLoader } from "dineway/runtime";
+---
 
-export const collections = {
-	_dineway: defineLiveCollection({ loader: dinewayLoader() }),
-};
+## Step 6 — Ongoing Management with AI
+
+After your site is live, continue using your AI agent for ongoing tasks:
+
+```text
+Use dineway-cli to create a new blog post about our weekend brunch special.
+```
+
+```text
+Use dineway-cli to update the menu with new summer dishes.
+```
+
+```text
+Use dineway-cli to upload these new restaurant photos and add them to the gallery.
+```
+
+The agent reads the `dineway-cli` skill and translates your natural-language requests into CLI commands automatically.
+
+---
+
+## Quick Reference
+
+### CLI Command Categories
+
+| Category | Commands | Needs Server? |
+| --- | --- | --- |
+| **Setup** | `init`, `dev`, `seed`, `export-seed` | No |
+| **Deploy** | `deploy forgeway/railway/docker/fly/gcp` | No |
+| **Auth** | `login`, `logout`, `whoami`, `auth setup-link`, `auth secret` | Yes (remote) |
+| **Content** | `content list/get/create/update/delete/publish/unpublish/schedule` | Yes |
+| **Schema** | `schema list/get/create/delete/add-field/remove-field` | Yes |
+| **Media** | `media list/get/upload/delete` | Yes |
+| **Search** | `search` | Yes |
+| **Taxonomy** | `taxonomy list/terms/add-term` | Yes |
+| **Menu** | `menu list/get` | Yes |
+| **Types** | `types` | Yes |
+
+### Field Types for Schema
+
+When adding fields to collections, use these types:
+
+| Type | Use For |
+| --- | --- |
+| `string` | Short text (titles, names) |
+| `text` | Long plain text |
+| `number` | Decimal numbers (prices) |
+| `integer` | Whole numbers (counts, calories) |
+| `boolean` | Yes/No flags |
+| `datetime` | Dates and times |
+| `image` | Photos and images |
+| `reference` | Link to another content item |
+| `portableText` | Rich text with formatting |
+| `json` | Structured data |
+
+### Authentication Flow
+
+The CLI resolves authentication automatically:
+
+1. `--token` flag (highest priority)
+2. `DINEWAY_TOKEN` from shell environment or `.env` file
+3. Stored credentials from `dineway login`
+4. Dev bypass — localhost only, no auth needed
+
+For local development, just run commands — auth is handled automatically.
+
+---
+
+## Common Questions
+
+### How do I access the admin panel?
+
+Visit `http://localhost:4321/_dineway/admin` (local) or `https://your-site.example.com/_dineway/admin` (deployed). You need an admin account — create one through the Setup Wizard on first visit.
+
+### How do I reset my admin account?
+
+Generate a new one-time setup link:
+
+```bash
+npx dineway auth setup-link
 ```
 
-## Querying Content in Astro Pages
+Open the link in your browser to register a new passkey.
+
+### Can I edit the site design after it's built?
 
-Use Dineway's query functions in your Astro components:
+Yes. The site is a standard [Astro](https://astro.build) project. You (or your AI agent) can modify the HTML, CSS, and components in the `src/` directory. Content managed by Dineway CMS is edited through the admin panel or CLI.
 
-```typescript
-import {
-	getDinewayCollection,
-	getDinewayEntry,
-	getSiteSettings,
-	getMenu,
-	getTaxonomyTerms,
-	getWidgetArea,
-	search,
-} from "dineway";
+### What data does the agent use to build my site?
 
-// Content
-const { entries } = await getDinewayCollection("posts");
-const { entry } = await getDinewayEntry("posts", "hello-world");
+The agent fetches publicly available business data: your restaurant name, address, hours, reviews, photos, and menu information. It does not access private accounts or require credentials.
 
-// Site settings
-const settings = await getSiteSettings();
+### Can I use Dineway for non-restaurant businesses?
 
-// Navigation
-const menu = await getMenu("primary");
+Yes. While optimized for restaurants, Dineway's content engine, admin panel, and plugin system work for any local business. Use the `building-dineway-site` skill instead of `building-restaurant-site`.
 
-// Taxonomies
-const categories = await getTaxonomyTerms("categories");
+---
 
-// Widgets
-const sidebar = await getWidgetArea("sidebar");
+## Agent Automation Reference
 
-// Search
-const results = await search("hello world", { collections: ["posts"] });
+> This section is for AI agents that read this README to automate site creation. Human readers can skip this.
+
+### Automated Restaurant Site Build
+
+```text
+STEP 1: Install skills
+  RUN: npx skills add https://github.com/dineway/dineway-skills
+
+STEP 2: Build the site
+  INVOKE SKILL: building-restaurant-site
+  INPUTS: restaurant name, city/country
+  The skill internally invokes:
+    - enrich-place-details (fetch real place data)
+    - brainstorming (design decisions)
+    - frontend-design (visual implementation)
+    - building-dineway-site (CMS integration)
+    - dineway-cli (content seeding, media upload)
+
+STEP 3: Validate
+  RUN: npx dineway dev
+  VERIFY: Site loads at http://localhost:4321
+  VERIFY: Admin panel loads at http://localhost:4321/_dineway/admin
+  VERIFY: Blog, News, Menu, Reviews, Gallery pages exist and render
+
+STEP 4: Deploy
+  RUN: npx dineway deploy forgeway
+  CAPTURE: Setup link from output
+  PRESENT: Setup link to user for admin account creation
 ```
 
+### Automated Content Management
+
+```text
+# List content in a collection
+RUN: npx dineway content list {collection} --json
+
+# Create content (auto-publishes)
+RUN: npx dineway content create {collection} --data '{...}' --json
+
+# Update content (requires --rev from a prior get)
+RUN: npx dineway content get {collection} {id} --json
+# Extract _rev from response
+RUN: npx dineway content update {collection} {id} --rev {_rev} --data '{...}' --json
+
+# Upload media
+RUN: npx dineway media upload {filepath} --alt "{description}" --json
+
+# Deploy changes
+RUN: npx dineway deploy forgeway
+```
+
+### Key Files in a Dineway Project
+
+```
+my-restaurant/
+├── astro.config.mjs          # Astro + Dineway configuration
+├── src/
+│   ├── live.config.ts         # Dineway content loader (boilerplate)
+│   ├── pages/                 # Site pages (server-rendered)
+│   ├── layouts/               # Layout components
+│   └── components/            # Reusable UI components
+├── seed/
+│   └── seed.json              # Schema + demo content seed file
+├── .dineway/
+│   ├── types.ts               # Generated TypeScript types
+│   └── schema.json            # Generated schema
+└── package.json
+```
+
+---
+
 ## Documentation
 
-Full documentation, guides, and API reference: [docs](https://docs.dineway.ai)
+Full documentation, guides, and API reference: [docs.dineway.ai](https://docs.dineway.ai)