@mycadet/assistant 0.12.9 → 0.12.10

package/src/avatar/__tests__/avatar-changed-telemetry.test.ts

@@ -1,217 +0,0 @@
-/**
- * Tests for the pure `avatar_changed` mapper and its no-op predicate. Nothing
- * here touches the filesystem: states are literals, and every payload the
- * mapper produces is checked against the synced wire schema.
- */
-import { describe, expect, test } from "bun:test";
-
-import { avatarChangedTelemetryEventSchema } from "../../telemetry/telemetry-wire.generated.js";
-import {
-  avatarChangedFields,
-  isSameAvatar,
-} from "../avatar-changed-telemetry.js";
-import { type AvatarState, NONE_AVATAR_STATE } from "../avatar-manifest.js";
-
-const TRAITS = { bodyShape: "blob", eyeStyle: "curious", color: "green" };
-
-const CHARACTER: AvatarState = {
-  kind: "character",
-  traits: TRAITS,
-  source: "builder",
-  image: null,
-  accent: { hex: "#4caf50", source: "palette" },
-};
-
-const UPLOADED: AvatarState = {
-  kind: "image",
-  traits: null,
-  source: "upload",
-  image: { updatedAt: "2026-01-01T00:00:00.000Z", etag: "etag-1" },
-  accent: { hex: "#c81e1e", source: "derived" },
-};
-
-/** The same PNG written again: fresh metadata, everything else equal. */
-const UPLOADED_REWRITTEN: AvatarState = {
-  ...UPLOADED,
-  image: { updatedAt: "2026-01-02T00:00:00.000Z", etag: "etag-2" },
-};
-
-/** An image manifest derived from legacy files: it names no source and no accent. */
-const UPLOADED_LEGACY: AvatarState = {
-  ...UPLOADED,
-  source: null,
-  accent: null,
-};
-
-const CUSTOM_ACCENT = { hex: "#123456", source: "custom" } as const;
-
-function parseOnTheWire(fields: ReturnType<typeof avatarChangedFields>) {
-  return avatarChangedTelemetryEventSchema.safeParse({
-    type: "avatar_changed",
-    daemon_event_id: "evt-avatar-changed-001",
-    recorded_at: 1_767_225_600_000,
-    assistant_version: "1.2.3",
-    ...fields,
-  });
-}
-
-describe("avatarChangedFields", () => {
-  test("a character carries its trait ids and palette accent", () => {
-    const fields = avatarChangedFields("set_character", UPLOADED, CHARACTER);
-    expect(fields).toStrictEqual({
-      action: "set_character",
-      kind: "character",
-      previous_kind: "image",
-      body_shape: "blob",
-      eye_style: "curious",
-      color: "green",
-      accent_hex: "#4caf50",
-      accent_source: "palette",
-    });
-  });
-
-  test("an image carries its derived accent and no trait keys", () => {
-    const fields = avatarChangedFields("upload_image", CHARACTER, UPLOADED);
-    expect(fields).toStrictEqual({
-      action: "upload_image",
-      kind: "image",
-      previous_kind: "character",
-      accent_hex: "#c81e1e",
-      accent_source: "derived",
-    });
-  });
-
-  test("a cleared avatar carries only the action and the two kinds", () => {
-    const fields = avatarChangedFields("clear", UPLOADED, NONE_AVATAR_STATE);
-    expect(fields).toStrictEqual({
-      action: "clear",
-      kind: "none",
-      previous_kind: "image",
-    });
-  });
-
-  test("a first set reports a previous kind of none", () => {
-    expect(
-      avatarChangedFields("set_character", NONE_AVATAR_STATE, CHARACTER)
-        .previous_kind,
-    ).toBe("none");
-  });
-
-  test("an upper-case palette hex is emitted lower case", () => {
-    const fields = avatarChangedFields("set_character", NONE_AVATAR_STATE, {
-      ...CHARACTER,
-      accent: { hex: "#4C9B50", source: "palette" },
-    });
-    expect(fields.accent_hex).toBe("#4c9b50");
-  });
-
-  test("the client OS rides along only when it is non-empty", () => {
-    const withOs = avatarChangedFields(
-      "generate_image",
-      NONE_AVATAR_STATE,
-      UPLOADED,
-      "macos",
-    );
-    expect(withOs.client_os).toBe("macos");
-
-    const emptyOs = avatarChangedFields(
-      "generate_image",
-      NONE_AVATAR_STATE,
-      UPLOADED,
-      "",
-    );
-    expect(emptyOs).not.toHaveProperty("client_os");
-  });
-
-  test("every payload parses under the synced wire schema", () => {
-    const payloads = [
-      avatarChangedFields("set_character", NONE_AVATAR_STATE, CHARACTER),
-      avatarChangedFields("upload_image", CHARACTER, UPLOADED, "web"),
-      avatarChangedFields("generate_image", NONE_AVATAR_STATE, UPLOADED),
-      avatarChangedFields("set_accent", UPLOADED, {
-        ...UPLOADED,
-        accent: CUSTOM_ACCENT,
-      }),
-      avatarChangedFields("clear", CHARACTER, NONE_AVATAR_STATE),
-    ];
-    for (const payload of payloads) {
-      const parsed = parseOnTheWire(payload);
-      expect(parsed.success).toBe(true);
-    }
-  });
-});
-
-describe("isSameAvatar", () => {
-  test("a character re-set with the same traits is the same", () => {
-    expect(isSameAvatar(CHARACTER, { ...CHARACTER })).toBe(true);
-  });
-
-  test("a character with one trait changed is not", () => {
-    expect(
-      isSameAvatar(CHARACTER, {
-        ...CHARACTER,
-        traits: { ...TRAITS, color: "blue" },
-      }),
-    ).toBe(false);
-  });
-
-  test("the same traits under a custom rather than palette accent is not", () => {
-    expect(
-      isSameAvatar(CHARACTER, {
-        ...CHARACTER,
-        accent: { hex: "#4caf50", source: "custom" },
-      }),
-    ).toBe(false);
-  });
-
-  test("a character whose accent was never recorded is the same under its palette accent", () => {
-    expect(isSameAvatar({ ...CHARACTER, accent: null }, CHARACTER)).toBe(true);
-  });
-
-  test("an image rewritten from the same bytes and source is the same", () => {
-    expect(isSameAvatar(UPLOADED, UPLOADED_REWRITTEN)).toBe(true);
-  });
-
-  test("an image whose bytes changed is not, even when every manifest field matches", () => {
-    expect(isSameAvatar(UPLOADED, UPLOADED_REWRITTEN, true)).toBe(false);
-  });
-
-  test("the same bytes from a different source is not", () => {
-    expect(isSameAvatar(UPLOADED, { ...UPLOADED, source: "ai" })).toBe(false);
-  });
-
-  test("the same bytes under a different accent is not", () => {
-    expect(
-      isSameAvatar(UPLOADED, {
-        ...UPLOADED,
-        accent: { hex: "#c81e1e", source: "custom" },
-      }),
-    ).toBe(false);
-  });
-
-  test("a legacy-derived image re-set from the same bytes is the same, whatever the source", () => {
-    expect(isSameAvatar(UPLOADED_LEGACY, UPLOADED)).toBe(true);
-    expect(isSameAvatar(UPLOADED_LEGACY, { ...UPLOADED, source: "ai" })).toBe(
-      true,
-    );
-  });
-
-  test("a custom accent over one that was never recorded is not", () => {
-    expect(
-      isSameAvatar(UPLOADED_LEGACY, { ...UPLOADED, accent: CUSTOM_ACCENT }),
-    ).toBe(false);
-  });
-
-  test("none is always the same as none", () => {
-    expect(isSameAvatar(NONE_AVATAR_STATE, NONE_AVATAR_STATE)).toBe(true);
-    expect(
-      isSameAvatar(NONE_AVATAR_STATE, { ...NONE_AVATAR_STATE }, true),
-    ).toBe(true);
-  });
-
-  test("none is never the same as an avatar", () => {
-    expect(isSameAvatar(NONE_AVATAR_STATE, CHARACTER)).toBe(false);
-    expect(isSameAvatar(NONE_AVATAR_STATE, UPLOADED)).toBe(false);
-    expect(isSameAvatar(UPLOADED, NONE_AVATAR_STATE)).toBe(false);
-  });
-});

package/src/avatar/avatar-changed-telemetry.ts

@@ -1,128 +0,0 @@
-/**
- * The pure half of the avatar store's telemetry: maps a before/after avatar
- * transition onto the `avatar_changed` wire event, so the store stays the one
- * caller of `recordTelemetryEvent`.
- */
-import type {
-  AvatarChangedTelemetryEvent,
-  TelemetryEventBase,
-} from "../telemetry/types.js";
-import type {
-  AvatarSource,
-  AvatarState,
-  CharacterTraits,
-} from "./avatar-manifest.js";
-
-export type AvatarChangeAction =
-  | "set_character"
-  | "upload_image"
-  | "generate_image"
-  | "set_accent"
-  | "clear";
-
-/** The sources an image can be set from. */
-export type ImageSource = Exclude<AvatarSource, "builder">;
-
-/** The action an image write counts as, by where the image came from. */
-export const IMAGE_ACTIONS: Readonly<Record<ImageSource, AvatarChangeAction>> =
-  { upload: "upload_image", ai: "generate_image" };
-
-/** The `avatar_changed` wire payload minus the fields `recordTelemetryEvent` stamps. */
-type AvatarChangedFields = Omit<
-  AvatarChangedTelemetryEvent,
-  keyof TelemetryEventBase
->;
-
-function sameTraits(
-  previous: CharacterTraits | null,
-  next: CharacterTraits | null,
-): boolean {
-  return (
-    previous?.bodyShape === next?.bodyShape &&
-    previous?.eyeStyle === next?.eyeStyle &&
-    previous?.color === next?.color
-  );
-}
-
-/** An unknown previous source cannot prove a change. */
-function sameSource(previous: AvatarState, next: AvatarState): boolean {
-  return previous.source === null || previous.source === next.source;
-}
-
-/**
- * A previous accent that was never recorded is an automatic one, so only a
- * custom accent over it proves a change.
- */
-function sameAccent(previous: AvatarState, next: AvatarState): boolean {
-  if (previous.accent === null) {
-    return next.accent?.source !== "custom";
-  }
-  return (
-    previous.accent.hex === next.accent?.hex &&
-    previous.accent.source === next.accent?.source
-  );
-}
-
-/**
- * Whether a mutation left the avatar as it was, so the store can skip the
- * event. Image metadata (`etag`, `updatedAt`) is ignored: a rewrite of the
- * same bytes changes it, and two different images can derive the same accent,
- * so the store compares bytes and passes the verdict as `imageBytesChanged`.
- * A manifest derived from legacy files or not yet backfilled carries no
- * source or accent, and an unknown value cannot prove a change.
- */
-export function isSameAvatar(
-  previous: AvatarState,
-  next: AvatarState,
-  imageBytesChanged = false,
-): boolean {
-  if (previous.kind !== next.kind) {
-    return false;
-  }
-  switch (next.kind) {
-    case "character":
-      return (
-        sameTraits(previous.traits, next.traits) && sameAccent(previous, next)
-      );
-    case "image":
-      return (
-        !imageBytesChanged &&
-        sameSource(previous, next) &&
-        sameAccent(previous, next)
-      );
-    case "none":
-      return true;
-  }
-}
-
-/**
- * The `avatar_changed` fields for a transition. Optional keys are omitted,
- * never set to `null` or `""`: the wire schema requires at least one
- * character, and a single failing field makes the server drop the whole event.
- */
-export function avatarChangedFields(
-  action: AvatarChangeAction,
-  previous: AvatarState,
-  next: AvatarState,
-  clientOs?: string,
-): AvatarChangedFields {
-  const fields: AvatarChangedFields = {
-    action,
-    kind: next.kind,
-    previous_kind: previous.kind,
-  };
-  if (next.kind === "character" && next.traits) {
-    fields.body_shape = next.traits.bodyShape;
-    fields.eye_style = next.traits.eyeStyle;
-    fields.color = next.traits.color;
-  }
-  if (next.accent) {
-    // One casing on the wire: the palette catalog spells its hexes upper case.
-    fields.accent_hex = next.accent.hex.toLowerCase();
-    fields.accent_source = next.accent.source;
-  }
-  if (clientOs) {
-    fields.client_os = clientOs;
-  }
-  return fields;
-}

package/src/calls/__tests__/call-funnel-telemetry.test.ts

@@ -1,204 +0,0 @@
-/**
- * Phone-call funnel rows: which ones the call store records and what they say.
- *
- * The recorder is mocked, as in `live-voice-session-telemetry.test.ts`: the
- * outbox and its consent gate are covered by `telemetry-events-outbox.test.ts`.
- * What these tests pin is the wiring that decides whether a row exists at all,
- * which is where the measurement silently goes wrong: a call that never
- * connects still has to count, a terminal status has to emit exactly one end
- * row however many writes follow it, and a call nobody spoke on has to say so.
- */
-
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-const recordPhoneCallStarted = mock(() => null);
-const recordPhoneCallEnded = mock(() => null);
-
-// Spread the real module rather than replacing it: the call store pulls other
-// recorders out of it, and a bare replacement makes those imports fail.
-const onboardingEventsStore =
-  await import("../../onboarding/onboarding-events-store.js");
-mock.module("../../onboarding/onboarding-events-store.js", () => ({
-  ...onboardingEventsStore,
-  recordPhoneCallStarted,
-  recordPhoneCallEnded,
-}));
-
-import { getDb } from "../../persistence/db-connection.js";
-import { initializeDb } from "../../persistence/db-init.js";
-import { conversations } from "../../persistence/schema/index.js";
-
-await initializeDb();
-
-// Values load after `mock.module` so the store picks up the mocked recorder.
-const { createCallSession, recordCallEvent, updateCallSession } =
-  await import("../call-store.js");
-
-let conversationSeq = 0;
-
-function makeConversation(): string {
-  const id = `conv-funnel-${++conversationSeq}`;
-  const now = Date.now();
-  getDb()
-    .insert(conversations)
-    .values({
-      id,
-      title: `Test conversation ${id}`,
-      createdAt: now,
-      updatedAt: now,
-    })
-    .run();
-  return id;
-}
-
-function startCall(opts?: {
-  direction?: "inbound" | "outbound";
-  callMode?: string;
-}): string {
-  const session = createCallSession({
-    conversationId: makeConversation(),
-    provider: "twilio",
-    direction: opts?.direction ?? "inbound",
-    fromNumber: "+15550100",
-    toNumber: "+15550101",
-    ...(opts?.callMode !== undefined ? { callMode: opts.callMode } : {}),
-  });
-  return session.id;
-}
-
-beforeEach(() => {
-  recordPhoneCallStarted.mockClear();
-  recordPhoneCallEnded.mockClear();
-});
-
-describe("call funnel start rows", () => {
-  test("an inbound call counts the moment its session row exists", () => {
-    // Before the provider has dialled and before any preflight can reject it:
-    // a call that never connects is the one the funnel most needs to count.
-    const callSessionId = startCall({ callMode: "normal" });
-
-    expect(recordPhoneCallStarted).toHaveBeenCalledTimes(1);
-    expect(recordPhoneCallStarted).toHaveBeenCalledWith({
-      callSessionId,
-      screen: "started_inbound:normal",
-    });
-  });
-
-  test("an outbound call is stamped by the direction it states", () => {
-    // Stated, not inferred: a verification or invite call dials out and
-    // carries no task, so task presence would misread as inbound.
-    startCall({ direction: "outbound", callMode: "verification" });
-
-    expect(recordPhoneCallStarted).toHaveBeenCalledWith(
-      expect.objectContaining({ screen: "started_outbound:verification" }),
-    );
-  });
-
-  test("an ordinary call stamps the normal mode it never writes", () => {
-    // createInboundVoiceSession and startCall leave callMode null; only the
-    // verification and invite flows set one.
-    startCall();
-
-    expect(recordPhoneCallStarted).toHaveBeenCalledWith(
-      expect.objectContaining({ screen: "started_inbound:normal" }),
-    );
-  });
-});
-
-describe("call funnel end rows", () => {
-  test("a completed call that took a turn reports no silence", () => {
-    const callSessionId = startCall({ callMode: "normal" });
-    updateCallSession(callSessionId, { status: "in_progress" });
-    recordCallEvent(callSessionId, "call_connected");
-    recordCallEvent(callSessionId, "caller_spoke", {
-      transcript: "hello",
-      transport: "media-stream",
-    });
-
-    updateCallSession(callSessionId, { status: "completed" });
-
-    expect(recordPhoneCallEnded).toHaveBeenCalledTimes(1);
-    expect(recordPhoneCallEnded).toHaveBeenCalledWith({
-      callSessionId,
-      screen: "ended_completed",
-      outcome: "completed",
-    });
-  });
-
-  test("a call that never connected is silent for that reason", () => {
-    const callSessionId = startCall({ callMode: "normal" });
-
-    updateCallSession(callSessionId, { status: "failed" });
-
-    expect(recordPhoneCallEnded).toHaveBeenCalledWith({
-      callSessionId,
-      screen: "ended_failed:silent_no_connect",
-      outcome: "failed",
-    });
-  });
-
-  test("a connected call nobody spoke on is silent on the line", () => {
-    // The distinction the rate lives on: the telephony leg worked and the
-    // conversation still never started.
-    const callSessionId = startCall({ callMode: "normal" });
-    updateCallSession(callSessionId, { status: "in_progress" });
-    recordCallEvent(callSessionId, "call_connected");
-
-    updateCallSession(callSessionId, { status: "completed" });
-
-    expect(recordPhoneCallEnded).toHaveBeenCalledWith(
-      expect.objectContaining({ screen: "ended_completed:silent_no_turn" }),
-    );
-  });
-
-  test("a call where only digits were pressed took no turn", () => {
-    // DTMF digits ride `caller_spoke` too; only a transcript is a turn.
-    const callSessionId = startCall({ callMode: "normal" });
-    updateCallSession(callSessionId, { status: "in_progress" });
-    recordCallEvent(callSessionId, "call_connected");
-    recordCallEvent(callSessionId, "caller_spoke", {
-      dtmfDigit: "4",
-      transport: "media-stream",
-    });
-
-    updateCallSession(callSessionId, { status: "completed" });
-
-    expect(recordPhoneCallEnded).toHaveBeenCalledWith(
-      expect.objectContaining({ screen: "ended_completed:silent_no_turn" }),
-    );
-  });
-
-  test("a cancelled call completed its course", () => {
-    // Only an error is a failure; a call cancelled before it connected ran
-    // exactly as far as it was asked to.
-    const callSessionId = startCall({ callMode: "normal" });
-
-    updateCallSession(callSessionId, { status: "cancelled" });
-
-    expect(recordPhoneCallEnded).toHaveBeenCalledWith(
-      expect.objectContaining({ outcome: "completed" }),
-    );
-  });
-
-  test("only the first terminal write records an end", () => {
-    // Terminal states are immutable, so the rejected second write must not
-    // produce a second row to pair with the one start.
-    const callSessionId = startCall({ callMode: "normal" });
-    updateCallSession(callSessionId, { status: "completed" });
-
-    updateCallSession(callSessionId, { status: "failed" });
-
-    expect(recordPhoneCallEnded).toHaveBeenCalledTimes(1);
-    expect(recordPhoneCallEnded).toHaveBeenCalledWith(
-      expect.objectContaining({ screen: "ended_completed:silent_no_connect" }),
-    );
-  });
-
-  test("a non-status update records nothing", () => {
-    const callSessionId = startCall({ callMode: "normal" });
-
-    updateCallSession(callSessionId, { providerCallSid: "CA-test" });
-
-    expect(recordPhoneCallEnded).not.toHaveBeenCalled();
-  });
-});

package/src/cli/commands/telemetry.help.ts

@@ -1,27 +0,0 @@
-/** Declarative help for the `assistant telemetry` command. */
-
-import type { CliCommandHelp } from "../lib/cli-command-help.js";
-
-export const telemetryHelp: CliCommandHelp = {
-  name: "telemetry",
-  description: "Manage telemetry reporting",
-  subcommands: [
-    {
-      name: "flush",
-      description: "Force-flush all pending telemetry events to the cloud",
-      helpText: `
-Reports how many events reached the cloud: 'sent' (POSTed), 'persisted'
-(confirmed written), and 'dropped' (sent - persisted — server-side drops plus
-events skipped at ingest validation). When nothing ships, prints why (e.g.
-nothing pending, opted out, not signed in).
-
-Pass --json for the raw summary:
-  { "flushed": true, "sent": 44, "persisted": 40, "dropped": 4 }
-  { "flushed": false, "reason": "opted-out" }
-
-Examples:
-  $ assistant telemetry flush
-  $ assistant telemetry flush --json`,
-    },
-  ],
-};

package/src/cli/commands/telemetry.ts

@@ -1,83 +0,0 @@
-import type { Command } from "commander";
-
-import { cliIpcCall, exitFromIpcResult } from "../../ipc/cli-client.js";
-import type { TelemetryFlushSummary } from "../../telemetry/usage-telemetry-reporter.js";
-import { applyCommandHelp, subcommand } from "../lib/cli-command-help.js";
-import { registerCommand } from "../lib/register-command.js";
-import { log } from "../logger.js";
-import { shouldOutputJson, writeOutput } from "../output.js";
-import { telemetryHelp } from "./telemetry.help.js";
-
-function describeSkip(reason: string): string {
-  switch (reason) {
-    case "nothing-pending":
-      return "No pending telemetry events to flush.";
-    case "opted-out":
-      return "Telemetry flush skipped: analytics sharing is opted out.";
-    case "no-credentials":
-      return "Telemetry flush skipped: not signed in to the cloud yet.";
-    case "unknown-consent":
-      return "Telemetry flush skipped: consent not yet resolved (will retry).";
-    case "checkpoint-unavailable":
-      return "Telemetry flush skipped: telemetry store unavailable (will retry).";
-    case "disabled":
-      return "Telemetry flush skipped: telemetry is disabled.";
-    case "post-failed":
-      return "Telemetry flush failed: the cloud rejected the request.";
-    default:
-      return `Telemetry flush skipped: ${reason}`;
-  }
-}
-
-function describeFlushed(r: {
-  sent: number;
-  persisted: number;
-  dropped: number;
-}): string {
-  const events = r.sent === 1 ? "event" : "events";
-  if (r.dropped === 0) {
-    return `Flushed ${r.sent} ${events} — all persisted.`;
-  }
-  return `Flushed ${r.sent} ${events} — ${r.persisted} persisted, ${r.dropped} dropped.`;
-}
-
-export function registerTelemetryCommand(program: Command): void {
-  registerCommand(program, {
-    name: telemetryHelp.name,
-    transport: "ipc",
-    description: telemetryHelp.description,
-    build: (telemetry) => {
-      applyCommandHelp(telemetry, telemetryHelp);
-
-      subcommand(telemetry, "flush").action(
-        async (_opts: Record<string, unknown>, cmd: Command) => {
-          const r = await cliIpcCall<TelemetryFlushSummary>(
-            "telemetry_flush",
-            {},
-          );
-          if (!r.ok) {
-            return exitFromIpcResult(
-              {
-                ok: false,
-                error: r.error,
-                statusCode: r.statusCode,
-              },
-              cmd,
-            );
-          }
-
-          const result = r.result!;
-          if (shouldOutputJson(cmd)) {
-            writeOutput(cmd, result);
-            return;
-          }
-          if (result.flushed) {
-            log.info(describeFlushed(result));
-          } else {
-            log.info(describeSkip(result.reason));
-          }
-        },
-      );
-    },
-  });
-}