@vellumai/assistant 0.4.10 → 0.4.12

package/src/config/bundled-skills/chatgpt-import/tools/chatgpt-import.ts

@@ -0,0 +1,449 @@
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { inflateRawSync } from "node:zlib";
+
+import { Database } from "bun:sqlite";
+import { eq } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/bun-sqlite";
+import { integer, real, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { v4 as uuid } from "uuid";
+
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+
+// -- Inline schema (only the tables this tool touches) --
+
+const conversations = sqliteTable("conversations", {
+  id: text("id").primaryKey(),
+  title: text("title"),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+  totalInputTokens: integer("total_input_tokens").notNull().default(0),
+  totalOutputTokens: integer("total_output_tokens").notNull().default(0),
+  totalEstimatedCost: real("total_estimated_cost").notNull().default(0),
+  contextSummary: text("context_summary"),
+  contextCompactedMessageCount: integer("context_compacted_message_count")
+    .notNull()
+    .default(0),
+  contextCompactedAt: integer("context_compacted_at"),
+  threadType: text("thread_type").notNull().default("standard"),
+  memoryScopeId: text("memory_scope_id").notNull().default("default"),
+});
+
+const messagesTable = sqliteTable("messages", {
+  id: text("id").primaryKey(),
+  conversationId: text("conversation_id")
+    .notNull()
+    .references(() => conversations.id),
+  role: text("role").notNull(),
+  content: text("content").notNull(),
+  createdAt: integer("created_at").notNull(),
+  metadata: text("metadata"),
+});
+
+const conversationKeys = sqliteTable("conversation_keys", {
+  id: text("id").primaryKey(),
+  conversationKey: text("conversation_key").notNull(),
+  conversationId: text("conversation_id")
+    .notNull()
+    .references(() => conversations.id, { onDelete: "cascade" }),
+  createdAt: integer("created_at").notNull(),
+});
+
+// -- Inline DB access --
+
+const schema = { conversations, messages: messagesTable, conversationKeys };
+
+function getDbPath(): string {
+  const baseDir = process.env.BASE_DATA_DIR?.trim() || homedir();
+  return join(baseDir, ".vellum", "workspace", "data", "db", "assistant.db");
+}
+
+let db: ReturnType<typeof drizzle<typeof schema>> | null = null;
+
+function getDb() {
+  if (!db) {
+    const dbPath = getDbPath();
+    const dbDir = join(dbPath, "..");
+    mkdirSync(dbDir, { recursive: true });
+    const sqlite = new Database(dbPath);
+    sqlite.exec("PRAGMA journal_mode=WAL");
+    sqlite.exec("PRAGMA foreign_keys = ON");
+    db = drizzle(sqlite, { schema });
+  }
+  return db;
+}
+
+// -- Inline conversation helpers --
+
+let lastTimestamp = 0;
+function monotonicNow(): number {
+  const now = Date.now();
+  lastTimestamp = Math.max(now, lastTimestamp + 1);
+  return lastTimestamp;
+}
+
+function createConversation(title: string) {
+  const database = getDb();
+  const now = Date.now();
+  const id = uuid();
+  const conversation = {
+    id,
+    title,
+    createdAt: now,
+    updatedAt: now,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalEstimatedCost: 0,
+    contextSummary: null as string | null,
+    contextCompactedMessageCount: 0,
+    contextCompactedAt: null as number | null,
+    threadType: "standard" as const,
+    memoryScopeId: "default",
+  };
+  database.insert(conversations).values(conversation).run();
+  return conversation;
+}
+
+function addMessage(conversationId: string, role: string, content: string) {
+  const database = getDb();
+  const now = monotonicNow();
+  const message = {
+    id: uuid(),
+    conversationId,
+    role,
+    content,
+    createdAt: now,
+  };
+  database.transaction((tx) => {
+    tx.insert(messagesTable).values(message).run();
+    tx.update(conversations)
+      .set({ updatedAt: now })
+      .where(eq(conversations.id, conversationId))
+      .run();
+  });
+  return message;
+}
+
+// -- ChatGPT export format types --
+
+interface ChatGPTContent {
+  content_type: string;
+  parts?: (string | null | Record<string, unknown>)[];
+}
+
+interface ChatGPTNode {
+  message: {
+    author: { role: string };
+    content: ChatGPTContent;
+    create_time?: number | null;
+  } | null;
+  parent: string | null;
+  children: string[];
+}
+
+interface ChatGPTConversation {
+  id?: string;
+  title: string;
+  create_time: number;
+  update_time: number;
+  current_node: string;
+  mapping: Record<string, ChatGPTNode>;
+}
+
+interface ImportedMessage {
+  role: string;
+  content: Array<{ type: string; text: string }>;
+  createdAt: number;
+}
+
+interface ImportedConversation {
+  sourceId: string;
+  title: string;
+  createdAt: number;
+  updatedAt: number;
+  messages: ImportedMessage[];
+}
+
+// -- Tool entry point --
+
+export async function run(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const filePath = input.file_path as string;
+
+  if (!filePath) {
+    return { content: "Error: file_path is required", isError: true };
+  }
+
+  if (!filePath.endsWith(".zip")) {
+    return {
+      content:
+        "Error: Only ZIP files are accepted. Please provide the ChatGPT export ZIP file.",
+      isError: true,
+    };
+  }
+
+  if (!existsSync(filePath)) {
+    return { content: `Error: File not found: ${filePath}`, isError: true };
+  }
+
+  let imported: ImportedConversation[];
+  try {
+    imported = parseChatGPTExport(filePath);
+  } catch (err) {
+    return {
+      content: `Error parsing export file: ${err instanceof Error ? err.message : String(err)}`,
+      isError: true,
+    };
+  }
+
+  if (imported.length === 0) {
+    return {
+      content: "No conversations found in the export file.",
+      isError: false,
+    };
+  }
+
+  const database = getDb();
+  let importedCount = 0;
+  let skippedCount = 0;
+  let messageCount = 0;
+
+  for (const conv of imported) {
+    const convKey = `chatgpt:${conv.sourceId}`;
+
+    const existing = database
+      .select()
+      .from(conversationKeys)
+      .where(eq(conversationKeys.conversationKey, convKey))
+      .get();
+
+    if (existing) {
+      skippedCount++;
+      continue;
+    }
+
+    const conversation = createConversation(conv.title);
+
+    for (const msg of conv.messages) {
+      addMessage(conversation.id, msg.role, JSON.stringify(msg.content));
+    }
+
+    // Override timestamps to match ChatGPT originals
+    database
+      .update(conversations)
+      .set({ createdAt: conv.createdAt, updatedAt: conv.updatedAt })
+      .where(eq(conversations.id, conversation.id))
+      .run();
+
+    // Update message timestamps to match ChatGPT originals
+    const dbMessages = database
+      .select({ id: messagesTable.id })
+      .from(messagesTable)
+      .where(eq(messagesTable.conversationId, conversation.id))
+      .orderBy(messagesTable.createdAt)
+      .all();
+
+    for (let i = 0; i < dbMessages.length && i < conv.messages.length; i++) {
+      database
+        .update(messagesTable)
+        .set({ createdAt: conv.messages[i].createdAt })
+        .where(eq(messagesTable.id, dbMessages[i].id))
+        .run();
+    }
+
+    database
+      .insert(conversationKeys)
+      .values({
+        id: uuid(),
+        conversationKey: convKey,
+        conversationId: conversation.id,
+        createdAt: Date.now(),
+      })
+      .run();
+
+    importedCount++;
+    messageCount += conv.messages.length;
+  }
+
+  const lines = [
+    `Imported ${importedCount} conversation(s) with ${messageCount} message(s).`,
+  ];
+  if (skippedCount > 0) {
+    lines.push(`Skipped ${skippedCount} already-imported conversation(s).`);
+  }
+  return { content: lines.join("\n"), isError: false };
+}
+
+// -- Parser --
+
+function parseChatGPTExport(zipPath: string): ImportedConversation[] {
+  const jsonContent = extractConversationsJsonFromZip(zipPath);
+
+  const raw = JSON.parse(jsonContent);
+  if (!Array.isArray(raw)) {
+    throw new Error("Expected conversations.json to contain a JSON array");
+  }
+
+  const results: ImportedConversation[] = [];
+  for (const conv of raw as ChatGPTConversation[]) {
+    const imported = parseConversation(conv);
+    if (imported) {
+      results.push(imported);
+    }
+  }
+  return results;
+}
+
+function parseConversation(
+  conv: ChatGPTConversation,
+): ImportedConversation | null {
+  const { mapping, current_node } = conv;
+  if (!mapping || !current_node || !mapping[current_node]) return null;
+
+  // Walk from current_node to root via parent pointers, then reverse for chronological order
+  const nodeIds: string[] = [];
+  let nodeId: string | null = current_node;
+  while (nodeId) {
+    nodeIds.push(nodeId);
+    nodeId = mapping[nodeId]?.parent ?? null;
+  }
+  nodeIds.reverse();
+
+  const messages: ImportedMessage[] = [];
+  for (const id of nodeIds) {
+    const node = mapping[id];
+    if (!node?.message) continue;
+
+    const { author, content, create_time } = node.message;
+    const role = author?.role;
+    if (role !== "user" && role !== "assistant") continue;
+
+    const text = extractText(content);
+    if (!text) continue;
+
+    messages.push({
+      role,
+      content: [{ type: "text", text }],
+      createdAt: create_time
+        ? Math.round(create_time * 1000)
+        : Math.round(conv.create_time * 1000),
+    });
+  }
+
+  if (messages.length === 0) return null;
+
+  return {
+    sourceId: conv.id ?? `${conv.title}-${conv.create_time}`,
+    title: conv.title || "Untitled",
+    createdAt: Math.round(conv.create_time * 1000),
+    updatedAt: Math.round(conv.update_time * 1000),
+    messages,
+  };
+}
+
+function extractText(content: ChatGPTContent): string {
+  if (!content?.parts) return "";
+  return content.parts
+    .filter((p): p is string => typeof p === "string")
+    .join("");
+}
+
+// -- ZIP extraction --
+
+function extractConversationsJsonFromZip(zipPath: string): string {
+  const buffer = readFileSync(zipPath);
+
+  // Find end of central directory record (EOCD signature: 0x06054b50)
+  let eocdOffset = -1;
+  for (let i = buffer.length - 22; i >= 0; i--) {
+    if (
+      buffer[i] === 0x50 &&
+      buffer[i + 1] === 0x4b &&
+      buffer[i + 2] === 0x05 &&
+      buffer[i + 3] === 0x06
+    ) {
+      eocdOffset = i;
+      break;
+    }
+  }
+  if (eocdOffset === -1) {
+    throw new Error(
+      "Invalid ZIP file: could not find end of central directory",
+    );
+  }
+
+  const centralDirOffset = buffer.readUInt32LE(eocdOffset + 16);
+  const centralDirEntries = buffer.readUInt16LE(eocdOffset + 10);
+
+  // Walk central directory to find conversations.json
+  let offset = centralDirOffset;
+  for (let i = 0; i < centralDirEntries; i++) {
+    if (
+      buffer[offset] !== 0x50 ||
+      buffer[offset + 1] !== 0x4b ||
+      buffer[offset + 2] !== 0x01 ||
+      buffer[offset + 3] !== 0x02
+    ) {
+      throw new Error("Invalid ZIP central directory entry");
+    }
+
+    const cdCompressedSize = buffer.readUInt32LE(offset + 20);
+    const fileNameLength = buffer.readUInt16LE(offset + 28);
+    const extraLength = buffer.readUInt16LE(offset + 30);
+    const commentLength = buffer.readUInt16LE(offset + 32);
+    const localHeaderOffset = buffer.readUInt32LE(offset + 42);
+    const fileName = buffer
+      .subarray(offset + 46, offset + 46 + fileNameLength)
+      .toString("utf-8");
+
+    if (
+      fileName === "conversations.json" ||
+      fileName.endsWith("/conversations.json")
+    ) {
+      return extractLocalFile(buffer, localHeaderOffset, cdCompressedSize);
+    }
+
+    offset += 46 + fileNameLength + extraLength + commentLength;
+  }
+
+  throw new Error("conversations.json not found in ZIP file");
+}
+
+function extractLocalFile(
+  buffer: Buffer,
+  offset: number,
+  cdCompressedSize: number,
+): string {
+  if (
+    buffer[offset] !== 0x50 ||
+    buffer[offset + 1] !== 0x4b ||
+    buffer[offset + 2] !== 0x03 ||
+    buffer[offset + 3] !== 0x04
+  ) {
+    throw new Error("Invalid ZIP local file header");
+  }
+
+  const compressionMethod = buffer.readUInt16LE(offset + 8);
+  const localCompressedSize = buffer.readUInt32LE(offset + 18);
+  const compressedSize =
+    cdCompressedSize > 0 ? cdCompressedSize : localCompressedSize;
+  const fileNameLength = buffer.readUInt16LE(offset + 26);
+  const extraLength = buffer.readUInt16LE(offset + 28);
+
+  const dataOffset = offset + 30 + fileNameLength + extraLength;
+  const fileData = buffer.subarray(dataOffset, dataOffset + compressedSize);
+
+  if (compressionMethod === 0) {
+    return fileData.toString("utf-8");
+  } else if (compressionMethod === 8) {
+    return inflateRawSync(fileData).toString("utf-8");
+  } else {
+    throw new Error(`Unsupported ZIP compression method: ${compressionMethod}`);
+  }
+}

package/src/config/bundled-skills/doordash/SKILL.md

@@ -0,0 +1,171 @@
+---
+name: "DoorDash"
+description: "Order food, groceries, and convenience items from DoorDash using the built-in CLI integration"
+user-invocable: true
+metadata:
+  {
+    "vellum":
+      {
+        "emoji": "\uD83C\uDF55",
+        "cli": { "command": "doordash", "entry": "doordash-entry.ts" },
+      },
+  }
+---
+
+You can order food from DoorDash for the user using the `doordash` CLI.
+
+## CLI Setup
+
+**IMPORTANT: Always use `host_bash` (not `bash`) for all `doordash` commands.** The DoorDash CLI needs host access for Chrome CDP, session cookies, and the CLI binary — none of which are available inside the sandbox.
+
+`doordash` is a standalone CLI tool installed at `~/.vellum/bin/doordash`. It should already be on your PATH. If `doordash` is not found, prepend `PATH="$HOME/.vellum/bin:$PATH"` to the command. Do NOT search for the binary, inspect wrapper scripts, or try to discover how the CLI works. Just run the commands as documented below.
+
+## Task Progress Widget
+
+A task progress card is shown automatically when you run your first `doordash` command. Its surface ID is `doordash-progress`. As each step completes, call `ui_update` with surface ID `doordash-progress` to update step statuses. Update `data.templateData.steps` — set completed steps to `"status": "completed"` with a `"detail"` string, the current step to `"status": "in_progress"`, and future steps to `"status": "pending"`. Adapt the steps to the actual flow (e.g. skip "Search restaurants" if the user named a specific store).
+
+## Typical Flow
+
+When the user asks you to order food (e.g. "Order pizza from Andiamo's"):
+
+1. **Check session** — run `doordash status --json`. If `loggedIn` is false or the session is expired, tell the user: "A Chrome window will open to the DoorDash login page. Please sign in there — I'll detect your login automatically and minimize the window." Then run `doordash refresh --json`. This starts a Ride Shotgun learn session that records your login and auto-stops once it detects you've signed in. The session is imported automatically. **This command blocks until login is complete — just wait for it.**
+
+   Keep the DoorDash Chrome window open in the background — it's needed for API requests.
+
+2. **Search** — run `doordash search "<query>" --json` to find matching restaurants. Present the top results to the user with name, rating, and delivery info. If the user named a specific restaurant, pick the best match. If ambiguous, ask.
+
+3. **Browse menu** — run `doordash menu <storeId> --json` to get the menu. Show the user the categories and items with prices. If the user already said what they want (e.g. "pepperoni pizza"), find the matching item(s). **For convenience/pharmacy stores** (CVS, Duane Reade, Walgreens etc.), the response will have `isRetail: true` and empty items — use `store-search` instead (see step 3b).
+
+3b. **Search within a retail store** — for convenience/pharmacy stores, run `doordash store-search <storeId> "<query>" --json` to find specific products. This returns items with IDs, prices, and menuIds that can be added to cart directly.
+
+4. **Get item details** (if needed) — run `doordash item <storeId> <itemId> --json` to see options/customizations. The response includes:
+   - `options`: each option group has `minSelections`/`maxSelections` indicating how many choices are required
+   - Each choice has `unitAmount` (price impact in cents), `defaultQuantity`, and possibly `nestedOptions` (sub-choices like milk type within a size selection)
+   - `specialInstructionsConfig`: whether special instructions are accepted, max length, and placeholder text
+
+   If the item has required options (like size or toppings), construct the `nestedOptions` JSON from the option/choice IDs and pass it via `--options`. Ask the user for preferences or pick sensible defaults.
+
+5. **Add to cart** — run `doordash cart add --store-id <id> --menu-id <id> --item-id <id> --item-name "<name>" --unit-price <cents> [--options '<json>'] [--special-instructions "<text>"] --json`. For subsequent items at the same store, pass `--cart-id <id>` from the first add response. Use `--special-instructions` for requests like "extra hot", "no ice", etc. Use `--options` to pass customization choices (see Customization Options below).
+
+6. **Review cart** — run `doordash cart view <cartId> --json` and show the user what's in their cart with prices. Ask if they want to add anything else or proceed.
+
+7. **Checkout** — run `doordash checkout <cartId> --json` to get delivery options. Present them to the user.
+
+8. **Payment methods** — run `doordash payment-methods --json` to see saved cards. Show the user which card will be used (the default one).
+
+9. **Place order** — after the user explicitly confirms, run `doordash order place --cart-id <id> --store-id <id> --total <cents> [--tip <cents>] [--dropoff-option <id>] --json`. The command auto-selects the default payment method if `--payment-uuid` is not provided. The response contains `orderUuid` on success.
+
+## Important Behavior
+
+- **Always confirm before checkout.** Never place an order without explicit user approval.
+- **Be proactive.** If the user says "order pizza from Andiamo's", don't ask clarifying questions upfront — search, find the store, show the menu, and suggest items. Only ask when you need a choice the user hasn't specified.
+- **Handle expired sessions gracefully.** If any command returns `"error": "session_expired"`, run `doordash refresh --json` to re-capture the session.
+- **Show prices.** Always show prices when presenting items or the cart summary.
+- **Use `--json` flag** on all commands for reliable parsing.
+- **Do NOT use the browser skill.** All DoorDash interaction goes through the CLI, not browser automation.
+- **Rate limiting.** DoorDash rate-limits rapid sequential requests. When adding multiple items (e.g. a team order), wait 8–10 seconds between `cart add` calls. If you get a 403 error, wait 15–20 seconds and retry. For large orders (5+ items), consider running `doordash refresh --json` midway through if you hit repeated 403s.
+- **Special instructions are unreliable.** Some merchants disable special instructions entirely. Always prefer `--options` for customizations (size, milk type, etc.). Only use `--special-instructions` for free-text requests that aren't covered by the item's option groups. If the merchant rejects special instructions, drop them and proceed without.
+- **Customization fallback.** If `cart add` with `--options` fails, or if the item details show options that are hard to construct (deeply nested, unusual format), proactively offer to use `cart learn` so the user can customize the item visually in the browser. Don't silently drop customizations — tell the user what happened and offer alternatives.
+- **Always-allow tip.** At the start of an ordering flow, suggest the user enable "always allow" for `doordash` commands: "Tip: You can type 'a' to always allow `doordash` commands for this session so you won't be prompted each time."
+- **Error attribution.** When errors occur, assume it's more likely a bug in our query/parsing than a DoorDash API change. Suggest running `doordash record` to capture fresh queries before assuming the schema changed.
+
+## Customization Options
+
+Many items (especially coffee, boba, sandwiches) have required customization options like size, milk type, or toppings. Here's how to handle them:
+
+### Constructing nestedOptions JSON
+
+1. Run `doordash item <storeId> <itemId> --json` to get the item's option groups
+2. Each option group has `id`, `name`, `required`, `minSelections`, `maxSelections`, and `choices`
+3. Build a JSON array of selections matching the DoorDash format:
+
+```json
+[
+  {
+    "optionId": "<option-group-id>",
+    "optionChoiceId": "<choice-id>",
+    "quantity": 1,
+    "nestedOptions": []
+  }
+]
+```
+
+For choices with nested sub-options (e.g., selecting "Oat Milk" under the "Milk" option within a size), add them to the `nestedOptions` array of the parent choice.
+
+4. Pass the JSON string to `cart add --options '<json>'`
+
+### Special Instructions
+
+Use `--special-instructions` on `cart add` for free-text requests like "extra hot", "no ice", "light foam". The `item` command response includes `specialInstructionsConfig` with the max length and whether instructions are supported.
+
+**Warning:** Some merchants disable special instructions entirely. If `specialInstructionsConfig.isEnabled` is false, or if the add-to-cart call returns an error about special requests, drop the instructions and retry without them. Always prefer `--options` for customizations — special instructions are a last resort for requests not covered by the item's option groups.
+
+### Learning Customizations via Ride Shotgun
+
+For complex items where constructing the JSON manually is difficult, use `cart learn`:
+
+1. Run `doordash cart learn --json`
+2. A Chrome window opens — navigate to the item, customize it visually, and click "Add to Cart"
+3. The command auto-detects the `updateCartItem` operation and extracts the exact `nestedOptions` and `specialInstructions`
+4. Use the extracted options directly with `cart add --options '<json>'`
+
+You can also extract options from an existing recording with `doordash inspect <recordingId> --extract-options --json`.
+
+### Coffee Order Example
+
+**User**: "Order a large oat milk latte with an extra shot from Blue Bottle"
+
+1. `doordash search "Blue Bottle" --json` -> finds store
+2. `doordash menu <storeId> --json` -> finds "Latte" item
+3. `doordash item <storeId> <latteItemId> --json` -> returns options:
+   - Size (required, min:1, max:1): Small (id:101), Medium (id:102), Large (id:103, +$1.00)
+   - Milk (required, min:1, max:1): Whole (id:201), Oat (id:202, +$0.70), Almond (id:203, +$0.70)
+   - Extras (optional, min:0, max:5): Extra Shot (id:301, +$0.90), Vanilla Syrup (id:302, +$0.60)
+4. Construct options JSON and add to cart:
+
+```
+doordash cart add --store-id <id> --menu-id <id> --item-id <id> --item-name "Latte" --unit-price 550 --options '[{"optionId":"size-group-id","optionChoiceId":"103","quantity":1,"nestedOptions":[]},{"optionId":"milk-group-id","optionChoiceId":"202","quantity":1,"nestedOptions":[]},{"optionId":"extras-group-id","optionChoiceId":"301","quantity":1,"nestedOptions":[]}]' --special-instructions "Extra hot" --json
+```
+
+## Command Reference
+
+```
+doordash status --json              # Check if logged in
+doordash refresh --json             # Capture fresh session via Ride Shotgun (auto-stops after login)
+doordash login --recording <path>   # Import session from a recording file manually
+doordash logout --json              # Clear session
+doordash search "<query>" --json    # Search restaurants
+doordash menu <storeId> --json      # Get store menu (auto-detects retail stores)
+doordash store-search <storeId> "<query>" --json  # Search items within a convenience/pharmacy store
+doordash item <storeId> <itemId> --json  # Get item details + options
+doordash cart add --store-id <id> --menu-id <id> --item-id <id> --item-name "<name>" --unit-price <cents> [--quantity <n>] [--cart-id <id>] [--options '<json>'] [--special-instructions "<text>"] --json
+doordash cart remove --cart-id <id> --item-id <orderItemId> --json
+doordash cart view <cartId> --json
+doordash cart list [--store-id <id>] --json
+doordash cart learn --json                 # Learn customization options by recording browser interaction
+doordash inspect <recordingId> --extract-options --json  # Extract nestedOptions from a recording
+doordash checkout <cartId> [--address-id <id>] --json
+doordash payment-methods --json     # List saved payment methods
+doordash order place --cart-id <id> --store-id <id> --total <cents> [--tip <cents>] [--delivery-option <type>] [--dropoff-option <id>] [--payment-uuid <uuid>] --json
+```
+
+## Example Interaction
+
+**User**: "Order a pepperoni pizza from Andiamo's"
+
+1. `doordash status --json` -> logged in
+2. `doordash search "Andiamo's" --json` -> finds store 22926474
+3. `doordash menu 22926474 --json` -> finds "Pepperoni Pizza Pie" (item 2956709006, $28.00)
+4. Tell user: "I found Pepperoni Pizza Pie at Andiamo's for $28.00. Adding it to your cart."
+5. `doordash cart add --store-id 22926474 --menu-id 12847574 --item-id 2956709006 --item-name "Pepperoni Pizza Pie" --unit-price 2800 --json`
+6. `doordash cart view <cartId> --json` -> show summary
+7. "Your cart has 1x Pepperoni Pizza Pie ($28.00), total $28.00. Ready to check out?"
+
+**User**: "I need Tylenol from CVS"
+
+1. `doordash status --json` -> logged in
+2. `doordash search "CVS" --json` -> finds store 1231787
+3. `doordash menu 1231787 --json` -> isRetail: true, categories but no items
+4. `doordash store-search 1231787 "tylenol" --json` -> finds results
+5. Show top results: "Tylenol Extra Strength Gelcaps (24 ct) - $8.79, Tylenol Extra Strength Caplets (100 ct) - $13.49..."
+6. User picks one -> add to cart with the item's `id`, `menuId`, and `unitAmount`