@alexkroman1/aai-cli 5.3.0 → 5.5.0

package/dist/templates/retail/seed.test.ts

@@ -0,0 +1,224 @@
+import { describe, expect, test } from "vitest";
+import { z } from "zod";
+import seedJson from "./seed.json";
+
+const AddressSchema = z.object({
+  address1: z.string(),
+  address2: z.string(),
+  city: z.string(),
+  state: z.string(),
+  country: z.string(),
+  zip: z.string(),
+});
+
+const PaymentMethodSchema = z.discriminatedUnion("source", [
+  z.object({ source: z.literal("gift_card"), id: z.string(), balance: z.number() }),
+  z.object({ source: z.literal("paypal"), id: z.string() }),
+  z.object({
+    source: z.literal("credit_card"),
+    id: z.string(),
+    brand: z.string(),
+    last_four: z.string(),
+  }),
+]);
+
+const VariantSchema = z.object({
+  item_id: z.string(),
+  options: z.record(z.string(), z.string()),
+  available: z.boolean(),
+  price: z.number(),
+});
+
+const SeedSchema = z.object({
+  products: z.record(
+    z.string(),
+    z.object({
+      name: z.string(),
+      product_id: z.string(),
+      variants: z.record(z.string(), VariantSchema),
+    }),
+  ),
+  users: z.record(
+    z.string(),
+    z.object({
+      user_id: z.string(),
+      name: z.object({ first_name: z.string(), last_name: z.string() }),
+      address: AddressSchema,
+      email: z.string(),
+      payment_methods: z.record(z.string(), PaymentMethodSchema),
+      orders: z.array(z.string()),
+    }),
+  ),
+  orders: z.record(
+    z.string(),
+    z.object({
+      order_id: z.string(),
+      user_id: z.string(),
+      address: AddressSchema,
+      items: z.array(
+        z.object({
+          name: z.string(),
+          product_id: z.string(),
+          item_id: z.string(),
+          price: z.number(),
+          options: z.record(z.string(), z.string()),
+        }),
+      ),
+      status: z.string(),
+      fulfillments: z
+        .array(z.object({ tracking_id: z.array(z.string()), item_ids: z.array(z.string()) }))
+        .optional(),
+      payment_history: z.array(
+        z.object({
+          transaction_type: z.enum(["payment", "refund"]),
+          amount: z.number(),
+          payment_method_id: z.string(),
+        }),
+      ),
+    }),
+  ),
+});
+
+// Parsed ONCE here so `store.ts` can cast at zero runtime cost. This test is
+// what makes that cast honest.
+const seed = SeedSchema.parse(seedJson);
+
+describe("seed shape", () => {
+  test("matches the tau2 schema", () => {
+    expect(Object.keys(seed.products)).toHaveLength(50);
+    expect(Object.keys(seed.users)).toHaveLength(6);
+    expect(Object.keys(seed.orders)).toHaveLength(22);
+  });
+
+  test("every order belongs to a seeded user and is listed on that user", () => {
+    for (const order of Object.values(seed.orders)) {
+      const user = seed.users[order.user_id];
+      expect(user, `order ${order.order_id} has no seeded user`).toBeDefined();
+      expect(user?.orders).toContain(order.order_id);
+    }
+  });
+
+  test("every user's listed orders are all seeded", () => {
+    for (const user of Object.values(seed.users)) {
+      for (const orderId of user.orders) {
+        expect(seed.orders[orderId], `${user.user_id} lists unseeded ${orderId}`).toBeDefined();
+      }
+    }
+  });
+
+  test("every ordered item resolves to a product variant with a matching price", () => {
+    for (const order of Object.values(seed.orders)) {
+      for (const item of order.items) {
+        const variant = seed.products[item.product_id]?.variants[item.item_id];
+        expect(
+          variant,
+          `${order.order_id}: ${item.item_id} missing from its product`,
+        ).toBeDefined();
+        expect(variant?.price).toBe(item.price);
+      }
+    }
+  });
+
+  test("every payment_method_id in an order resolves on its user", () => {
+    for (const order of Object.values(seed.orders)) {
+      const user = seed.users[order.user_id];
+      for (const payment of order.payment_history) {
+        expect(
+          user?.payment_methods[payment.payment_method_id],
+          `${order.order_id}: unknown method ${payment.payment_method_id}`,
+        ).toBeDefined();
+      }
+    }
+  });
+
+  test("names + zips are unique, so find_user_id_by_name_zip is unambiguous", () => {
+    const keys = Object.values(seed.users).map((u) =>
+      `${u.name.first_name}|${u.name.last_name}|${u.address.zip}`.toLowerCase(),
+    );
+    expect(new Set(keys).size).toBe(keys.length);
+  });
+
+  test("emails are unique", () => {
+    const emails = Object.values(seed.users).map((u) => u.email.toLowerCase());
+    expect(new Set(emails).size).toBe(emails.length);
+  });
+});
+
+describe("seed coverage — each datum backs a specific test in agent.test.ts", () => {
+  test("every status the tools branch on is present", () => {
+    const statuses = new Set(Object.values(seed.orders).map((o) => o.status));
+    for (const s of ["pending", "processed", "delivered", "cancelled"]) {
+      expect(statuses, `no ${s} order seeded`).toContain(s);
+    }
+  });
+
+  test("aarav_anderson has one gift card at $17.00 and no other method", () => {
+    const methods = seed.users.aarav_anderson_8794?.payment_methods ?? {};
+    expect(Object.keys(methods)).toEqual(["gift_card_7245904"]);
+    expect(methods.gift_card_7245904).toMatchObject({ source: "gift_card", balance: 17 });
+  });
+
+  test("harper_brown holds no gift card, so a return must go to the original method", () => {
+    const methods = Object.values(seed.users.harper_brown_7363?.payment_methods ?? {});
+    expect(methods.some((m) => m.source === "gift_card")).toBe(false);
+    expect(methods.length).toBeGreaterThanOrEqual(2);
+  });
+
+  test("olivia_ito holds all three payment-method kinds", () => {
+    const sources = Object.values(seed.users.olivia_ito_3591?.payment_methods ?? {})
+      .map((m) => m.source)
+      .sort();
+    expect(sources).toEqual(["credit_card", "gift_card", "paypal"]);
+  });
+
+  test("olivia_ito has three pending orders, so ordinal shorthand must disambiguate", () => {
+    const pending = (seed.users.olivia_ito_3591?.orders ?? []).filter(
+      (id) => seed.orders[id]?.status === "pending",
+    );
+    expect(pending).toHaveLength(3);
+  });
+
+  test("#W4316152 carries a duplicate item id", () => {
+    const items = seed.orders["#W4316152"]?.items.map((i) => i.item_id) ?? [];
+    expect(items).toEqual(["7292993796", "7292993796"]);
+  });
+
+  test("#W1840144 carries a duplicate item id on a non-gift-card order", () => {
+    const order = seed.orders["#W1840144"];
+    const dupes = (order?.items ?? []).filter((i) => i.item_id === "8590708195");
+    expect(dupes).toHaveLength(2);
+    expect(order?.payment_history[0]?.payment_method_id).toBe("paypal_2306935");
+  });
+
+  test("the exchange arithmetic every test asserts is reachable", () => {
+    const cases: [string, string, string, number][] = [
+      // product_id, from item, to item, expected diff
+      ["1762337868", "1304426904", "4725166838", 36.32], // exceeds aarav's $17
+      ["9832717871", "7292993796", "3909406921", 3.45], // fits
+      ["4354588079", "6242772310", "6200867091", -40.86], // refund direction
+      ["4760268021", "8997785118", "6017636844", -382.03], // pending modify refund
+      ["4760268021", "6017636844", "9844888101", 167.37], // exceeds anya's $51 card
+    ];
+    for (const [productId, from, to, diff] of cases) {
+      const variants = seed.products[productId]?.variants;
+      const a = variants?.[from];
+      const b = variants?.[to];
+      expect(a, `${productId}: ${from} trimmed away`).toBeDefined();
+      expect(b, `${productId}: ${to} trimmed away`).toBeDefined();
+      expect(b?.available, `${to} must be available to be an exchange target`).toBe(true);
+      expect(Math.round(((b?.price ?? 0) - (a?.price ?? 0)) * 100) / 100).toBe(diff);
+    }
+  });
+
+  test("an unavailable variant survives trimming for the 'not available' path", () => {
+    expect(seed.products["9832717871"]?.variants["6454334990"]?.available).toBe(false);
+  });
+
+  test("every product keeps at least two variants, so an exchange always has a target", () => {
+    for (const [pid, product] of Object.entries(seed.products)) {
+      expect(Object.keys(product.variants).length, `${pid} has too few variants`).toBeGreaterThan(
+        1,
+      );
+    }
+  });
+});

package/dist/templates/retail/shared.test.ts

@@ -0,0 +1,192 @@
+import { describe, expect, test } from "vitest";
+import seedJson from "./seed.json";
+import type { RetailState, Store } from "./shared.ts";
+import { buildScriptBullets, DEMO_PERSONAS, storeView } from "./shared.ts";
+
+function makeState(authenticatedUserId: string | null): RetailState {
+  return {
+    store: structuredClone(seedJson) as unknown as Store,
+    authenticatedUserId,
+    callSeq: 3,
+    activity: [{ seq: 3, tool: "get_order_details", summary: "read #W5866402", at: 0 }],
+    focus: { orderId: "#W5866402" },
+  };
+}
+
+describe("storeView", () => {
+  test("projects nothing identifying before authentication", () => {
+    const view = storeView({ retail: makeState(null) });
+    expect(view.customer).toBeNull();
+    expect(view.orders).toEqual([]);
+  });
+
+  test("an absent state slot degrades to an empty view", () => {
+    const view = storeView({});
+    expect(view.customer).toBeNull();
+    expect(view.orders).toEqual([]);
+    expect(view.callSeq).toBe(0);
+  });
+
+  test("projects the authenticated customer and only their orders", () => {
+    const view = storeView({ retail: makeState("olivia_ito_3591") });
+    expect(view.customer?.name).toBe("Olivia Ito");
+    expect(view.customer?.email).toBe("olivia.ito5204@example.com");
+    expect(view.orders.map((o) => o.orderId).sort((a, b) => a.localeCompare(b))).toEqual(
+      ["#W3657213", "#W5353646", "#W5442520", "#W5866402", "#W7941031"].sort((a, b) =>
+        a.localeCompare(b),
+      ),
+    );
+  });
+
+  test("projects live gift-card balances, since refunds move them", () => {
+    const state = makeState("olivia_ito_3591");
+    const view = storeView({ retail: state });
+    const card = view.customer?.paymentMethods.find((m) => m.id === "gift_card_7794233");
+    expect(card?.balance).toBe(56);
+  });
+
+  test("no other customer's email, address, or payment method reaches the client", () => {
+    const view = storeView({ retail: makeState("olivia_ito_3591") });
+    const json = JSON.stringify(view);
+    for (const leaked of [
+      "aarav.anderson9752@example.com",
+      "harper.brown3965@example.com",
+      "emma.smith3991@example.com",
+      "gift_card_7245904",
+      "paypal_2306935",
+      "#W4316152",
+      "#W1840144",
+    ]) {
+      expect(json, `projection leaked ${leaked}`).not.toContain(leaked);
+    }
+  });
+
+  test("carries callSeq, activity and focus through", () => {
+    const view = storeView({ retail: makeState("olivia_ito_3591") });
+    expect(view.callSeq).toBe(3);
+    expect(view.activity).toHaveLength(1);
+    expect(view.focus.orderId).toBe("#W5866402");
+  });
+
+  test("order totals sum the payments, not the items", () => {
+    const view = storeView({ retail: makeState("olivia_ito_3591") });
+    const delivered = view.orders.find((o) => o.orderId === "#W5866402");
+    expect(delivered?.total).toBe(3203.78);
+  });
+});
+
+describe("DEMO_PERSONAS", () => {
+  test("lists every seeded customer", () => {
+    expect(DEMO_PERSONAS).toHaveLength(Object.keys(seedJson.users).length);
+  });
+
+  test("every persona's email, name and zip match its seed record", () => {
+    const users = Object.values((structuredClone(seedJson) as unknown as Store).users);
+    for (const persona of DEMO_PERSONAS) {
+      const user = users.find((u) => u.email === persona.email);
+      expect(user, `no seeded customer has email ${persona.email}`).toBeDefined();
+      expect(`${user?.name.first_name} ${user?.name.last_name}`).toBe(persona.name);
+      expect(user?.address.zip).toBe(persona.zip);
+    }
+  });
+
+  test("every persona carries a hint, so a user can pick a path deliberately", () => {
+    for (const persona of DEMO_PERSONAS) {
+      expect(persona.hint.length, persona.name).toBeGreaterThan(20);
+    }
+  });
+});
+
+describe("swapOptions", () => {
+  test("empty when no order is focused", () => {
+    const state = makeState("olivia_ito_3591");
+    state.focus = {};
+    expect(storeView({ retail: state }).swapOptions).toEqual([]);
+  });
+
+  test("lists available alternatives for the focused order's items", () => {
+    // makeState focuses #W5866402 — Espresso Machine + Sneakers.
+    const view = storeView({ retail: makeState("olivia_ito_3591") });
+    expect(view.swapOptions).toHaveLength(2);
+    const espresso = view.swapOptions.find((s) => s.itemId === "6242772310");
+    expect(espresso?.itemName).toBe("Espresso Machine");
+    expect(espresso?.alternatives.length).toBeGreaterThan(0);
+    expect(espresso?.alternatives.map((a) => a.itemId)).not.toContain("6242772310");
+  });
+
+  test("never offers an unavailable variant as a target", () => {
+    const state = makeState("aarav_anderson_8794");
+    state.focus = { orderId: "#W4316152" };
+    const view = storeView({ retail: state });
+    const ids = view.swapOptions.flatMap((s) => s.alternatives.map((a) => a.itemId));
+    // 6454334990 is a Tea Kettle variant with available: false.
+    expect(ids).not.toContain("6454334990");
+  });
+
+  test("caps both axes so the payload stays bounded", () => {
+    const state = makeState("aarav_anderson_8794");
+    state.focus = { orderId: "#W9311069" }; // five items
+    const view = storeView({ retail: state });
+    expect(view.swapOptions.length).toBeLessThanOrEqual(3);
+    for (const option of view.swapOptions) {
+      expect(option.alternatives.length).toBeLessThanOrEqual(4);
+    }
+  });
+
+  test("a focus on another customer's order projects nothing", () => {
+    const state = makeState("olivia_ito_3591");
+    state.focus = { orderId: "#W4316152" }; // aarav's
+    const view = storeView({ retail: state });
+    expect(view.swapOptions).toEqual([]);
+    expect(JSON.stringify(view)).not.toContain("#W4316152");
+  });
+});
+
+describe("buildScriptBullets", () => {
+  test("pre-auth bullets name both lookup paths using the first persona", () => {
+    const bullets = buildScriptBullets(makeState(null));
+    expect(bullets.join(" ")).toContain(DEMO_PERSONAS[0]?.email ?? "");
+    expect(bullets.join(" ")).toContain(DEMO_PERSONAS[0]?.zip ?? "");
+  });
+
+  test("undefined state yields the pre-auth bullets", () => {
+    expect(buildScriptBullets(undefined).length).toBeGreaterThan(0);
+  });
+
+  test("a customer with pending orders is offered cancel and address change", () => {
+    const bullets = buildScriptBullets(makeState("olivia_ito_3591")).join(" ").toLowerCase();
+    expect(bullets).toContain("cancel");
+    expect(bullets).toContain("address");
+  });
+
+  test("a customer with a delivered order is offered a return naming a real item", () => {
+    const bullets = buildScriptBullets(makeState("olivia_ito_3591")).join(" ");
+    expect(bullets.toLowerCase()).toContain("return");
+    expect(bullets).toMatch(/Espresso Machine|Sneakers/);
+  });
+
+  test("the exchange bullet names a real alternative option, not 'a different option'", () => {
+    const state = makeState("olivia_ito_3591");
+    const bullets = buildScriptBullets(state);
+    const exchange = bullets.find((b) => b.toLowerCase().includes("exchange"));
+    expect(exchange).toBeDefined();
+    // It must quote option values that really exist on that product.
+    const espresso = state.store.products["4354588079"];
+    const optionWords = Object.values(espresso?.variants ?? {})
+      .filter((v) => v.available)
+      .flatMap((v) => Object.values(v.options));
+    expect(optionWords.some((word) => exchange?.includes(word))).toBe(true);
+  });
+
+  test("no return bullet when the customer has no delivered order", () => {
+    // anya_garcia_3271 has cancelled + processed + pending, no delivered.
+    const bullets = buildScriptBullets(makeState("anya_garcia_3271")).join(" ").toLowerCase();
+    expect(bullets).not.toContain("return");
+    expect(bullets).not.toContain("exchange");
+  });
+
+  test("bullets stay short enough to render in a sidebar", () => {
+    const bullets = buildScriptBullets(makeState("olivia_ito_3591"));
+    expect(bullets.length).toBeLessThanOrEqual(6);
+  });
+});