@zaip-ai/cli 2.2.0 → 3.0.0

package/templates/.agents/dashboard/modules/cost-monitor/src/react/CostTables.test.ts

@@ -1,19 +1,14 @@
 import { describe, expect, it } from "vitest";
 import type { CostGroupRow } from "../contracts.js";
-import { displayModelName, isModelAuditRow, sumModelDurationMs } from "./CostModelsAuditTable.js";
 import {
   agentRunModelPresentation,
   type CostDeveloperAttributionRow,
   CostDeveloperAttributionTable,
   CostGroupsTable,
-  CostRunsTable,
-  contextUpliftUsd,
   costGroupsScrollLabel,
   costPeriodTotalAriaLabel,
   costRunsDurationTotal,
   costRunsFooterLabel,
-  costRunsScrollLabel,
-  displayCostGroupLabel,
   formatAuditableCompactNumber,
   formatAuditableCurrency,
   formatAuditableDuration,
@@ -27,12 +22,9 @@ import {
   formatServiceTier,
   formatTokenBackedDuration,
   formatUsd,
-  hasCollectedUsage,
   isCompactRunColumnVisible,
-  isDisplayableModel,
   ratio,
   runOriginBadge,
-  sortCostValue,
 } from "./CostTables.js";
 
 describe("Agent Run model presentation", () => {
@@ -199,6 +191,24 @@ describe("runtime availability", () => {
   });
 });
 describe("grouped cost availability", () => {
+  const unavailableGroup = {
+    key: "unknown",
+    label: "Sem telemetria",
+    latest_started_at: "2026-07-24T20:00:00.000Z",
+    run_count: 2,
+    task_count: 1,
+    prd_count: 0,
+    spec_count: 0,
+    evidence_count: 0,
+    test_count: 0,
+    event_count: 2,
+    total_tokens: null,
+    estimated_usd: null,
+    estimated_brl: null,
+    duration_ms: null,
+    duration: { known_sum: 0, unknown: 2, complete: false, coverage_ratio: 0 },
+    coverage: { events: 2, tokens: 0, usd: 0, brl: 0 },
+  } as const;
   it("uses the requested Cost Monitor developer metric columns without Operations source or coverage", () => {
     const table = CostDeveloperAttributionTable({
       locale: "pt-BR",
@@ -320,24 +330,6 @@ describe("grouped cost availability", () => {
     } as never;
     expect(costRunsDurationTotal([root, child, child])).toBe(11_000);
   });
-  const unavailableGroup = {
-    key: "unknown",
-    label: "Sem telemetria",
-    latest_started_at: "2026-07-24T20:00:00.000Z",
-    run_count: 2,
-    task_count: 1,
-    prd_count: 0,
-    spec_count: 0,
-    evidence_count: 0,
-    test_count: 0,
-    event_count: 2,
-    total_tokens: null,
-    estimated_usd: null,
-    estimated_brl: null,
-    duration_ms: null,
-    duration: { known_sum: 0, unknown: 2, complete: false, coverage_ratio: 0 },
-    coverage: { events: 2, tokens: 0, usd: 0, brl: 0 },
-  } as const;
   it.each([
     "daily",
     "monthly",
@@ -464,7 +456,6 @@ describe("grouped cost availability", () => {
     expect(columns.find((column) => column.key === "tasks")?.label).toBe("Tarefas");
     expect(table.props.defaultSort).toEqual({ key: "cost", direction: "desc" });
   });
-
   it("renders missing Agent numeric metrics as zero, keeping model rendering independent", () => {
     const missing: CostGroupRow = {
       ...unavailableGroup,
@@ -490,502 +481,4 @@ describe("grouped cost availability", () => {
     }
     expect(columns.find((c) => c.key === "cost")?.render?.(missing)).not.toContain("Indisponível");
   });
-
-  it("keeps legacy codex identity fields blank and uses the complete paged aggregate in its footer", () => {
-    const table = CostGroupsTable({
-      rows: [
-        {
-          ...unavailableGroup,
-          key: "codex",
-          label: "codex",
-          run_count: 1,
-          total_tokens: 10,
-          estimated_brl: 1,
-          estimated_usd: 1,
-        },
-      ],
-      currency: "BRL",
-      locale: "pt-BR",
-      showDateTime: false,
-      showAgentIdentity: true,
-      totals: {
-        ...unavailableGroup,
-        run_count: 2,
-        task_count: 2,
-        total_tokens: 30,
-        estimated_brl: 3,
-        estimated_usd: 3,
-        duration: { known_sum: 0, unknown: 1, complete: false, coverage_ratio: 0 },
-      },
-    });
-    const columns = table.props.columns as Array<{
-      key: string;
-      render?: (row: { persona?: string | null; job?: string | null }) => unknown;
-      footer?: unknown;
-    }>;
-    expect(columns.find((column) => column.key === "persona")?.render?.({ persona: null })).toBe(
-      "",
-    );
-    expect(columns.find((column) => column.key === "job")?.render?.({ job: null })).toBe("");
-    expect(columns.find((column) => column.key === "runs")?.footer).toBe(2);
-    const tokenFooter = columns.find((column) => column.key === "tokens")?.footer;
-    expect(tokenFooter).toBeDefined();
-    expect((tokenFooter as { props: { children: unknown } }).props.children).toBe("30");
-  });
-  it("renders model groups without date and labels distinct invocation tasks", () => {
-    const table = CostGroupsTable({
-      rows: [{ ...unavailableGroup, key: "unavailable", label: "unavailable", task_count: 0 }],
-      currency: "BRL",
-      locale: "pt-BR",
-      showDateTime: false,
-      showInvocationTasks: true,
-    });
-    const columns = table.props.columns as Array<{ key: string; label: string; hidden?: boolean }>;
-    expect(columns.find((column) => column.key === "latestStartedAt")?.hidden).toBe(true);
-    expect(columns.find((column) => column.key === "tasks")?.label).toBe("Tarefas com invocação");
-  });
-  it("renders the requested model-analysis columns with explicit numeric zeroes", () => {
-    const model: CostGroupRow = {
-      ...unavailableGroup,
-      key: "gpt-6-astra",
-      label: "gpt-6-astra",
-      prd_count: 2,
-      spec_count: 3,
-      task_count: null,
-      run_count: 8,
-      test_count: null,
-      evidence_count: 1,
-      conversation_count: 0,
-    };
-    const table = CostGroupsTable({
-      rows: [model],
-      currency: "BRL",
-      locale: "pt-BR",
-      showDateTime: false,
-      showModelLifecycleDetails: true,
-      totals: {
-        ...model,
-        prd_count: 2,
-        spec_count: 3,
-        task_count: null,
-        test_count: null,
-        evidence_count: 1,
-      },
-    });
-    const columns = table.props.columns as Array<{
-      key: string;
-      label: string;
-      render?: (row: typeof model) => unknown;
-      sortValue?: (row: typeof model) => unknown;
-      description?: string;
-    }>;
-    expect(columns.map((column) => column.key).filter((key) => key !== "latestStartedAt")).toEqual([
-      "label",
-      "prds",
-      "specs",
-      "tasks",
-      "conversations",
-      "runs",
-      "tests",
-      "evidences",
-      "duration",
-      "tokens",
-      "cost",
-    ]);
-    expect(columns.find((column) => column.key === "tasks")?.label).toBe("Tasks");
-    expect(columns.find((column) => column.key === "tasks")?.render?.(model)).toBe("0");
-    expect(columns.find((column) => column.key === "conversations")?.render?.(model)).toBe("0");
-    expect(columns.find((column) => column.key === "conversations")?.description).toContain(
-      "unassisted",
-    );
-    expect(columns.find((column) => column.key === "tasks")?.description).toContain(
-      "creation_run_id",
-    );
-    expect(columns.find((column) => column.key === "runs")?.description).toContain(
-      "sem distribuir",
-    );
-    for (const key of ["prds", "specs", "tasks", "conversations", "runs", "tests", "evidences"])
-      expect(columns.find((column) => column.key === key)?.sortValue).toBeDefined();
-    expect(columns.find((column) => column.key === "cost")?.label).toBe("Custos");
-    expect(
-      columns.find((column) => column.key === "tokens")?.render?.({ ...model, total_tokens: null }),
-    ).toBe("0");
-    expect(
-      columns.find((column) => column.key === "prds")?.render?.({ ...model, prd_count: null }),
-    ).toBe("0");
-    expect(
-      columns.find((column) => column.key === "specs")?.render?.({ ...model, spec_count: null }),
-    ).toBe("0");
-    expect(
-      columns.find((column) => column.key === "tests")?.render?.({ ...model, test_count: null }),
-    ).toBe("0");
-    expect(
-      columns
-        .find((column) => column.key === "evidences")
-        ?.render?.({ ...model, evidence_count: null }),
-    ).toBe("0");
-    expect(columns.find((column) => column.key === "conversations")?.sortValue?.(model)).toBe(0);
-    expect(columns.find((column) => column.key === "tests")?.description).toContain(
-      "Run registradora",
-    );
-    expect(columns.find((column) => column.key === "evidences")?.description).toContain(
-      "Run registradora",
-    );
-    expect(
-      columns
-        .find((column) => column.key === "duration")
-        ?.render?.({
-          ...model,
-          duration: { known_sum: 0, unknown: 1, complete: false, coverage_ratio: 0 },
-        }),
-    ).toBe("0");
-    expect(
-      columns.find((column) => column.key === "cost")?.render?.({ ...model, estimated_brl: null }),
-    ).toContain("0,00");
-    expect(
-      columns
-        .find((column) => column.key === "tokens")
-        ?.sortValue?.({ ...model, total_tokens: null }),
-    ).toBe(0);
-    expect(
-      columns
-        .find((column) => column.key === "duration")
-        ?.sortValue?.({
-          ...model,
-          duration: { known_sum: 0, unknown: 1, complete: false, coverage_ratio: 0 },
-        }),
-    ).toBe(0);
-    expect(
-      columns
-        .find((column) => column.key === "cost")
-        ?.sortValue?.({ ...model, estimated_brl: null }),
-    ).toBe(0);
-  });
-  it("keeps a complete observed zero visible without a partial coverage label", () => {
-    const observedZeroGroup = {
-      ...unavailableGroup,
-      duration_ms: 0,
-      duration: { known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 },
-    };
-    const table = CostGroupsTable({ rows: [observedZeroGroup], currency: "BRL", locale: "pt-BR" });
-    const duration = (
-      table.props.columns as Array<{
-        key: string;
-        render: (row: typeof observedZeroGroup) => unknown;
-        footer?: { props: { children: unknown } };
-      }>
-    ).find((column) => column.key === "duration");
-    expect(duration?.render(observedZeroGroup)).toBe(formatAuditableDuration(0, "pt-BR"));
-    expect(duration?.footer?.props.children).toBe(formatAuditableDuration(0, "pt-BR"));
-  });
-  it("presents the factual known portion of a partial duration subtotal", () => {
-    const partial = {
-      ...unavailableGroup,
-      total_tokens: 1_000,
-      duration_ms: null,
-      duration: { known_sum: 20_000, unknown: 1, complete: false, coverage_ratio: 0.5 },
-    };
-    const table = CostGroupsTable({ rows: [partial], currency: "BRL", locale: "pt-BR" });
-    const duration = (
-      table.props.columns as Array<{ key: string; footer?: { props: { children: unknown } } }>
-    ).find((column) => column.key === "duration");
-    expect(duration?.footer?.props.children).toBe("20 seg");
-  });
-  it("does not expose coverage as a detailed Run column", () => {
-    const table = CostRunsTable({
-      rows: [unavailableGroup] as never,
-      onOpenRun: () => undefined,
-      currency: "BRL",
-      locale: "pt-BR",
-    });
-    const columns = table.props.columns as Array<{ key: string }>;
-    expect(columns.some((column) => column.key === "coverage")).toBe(false);
-  });
-  it("sorts unavailable Run numeric metrics as unavailable", () => {
-    const unavailableRun = { ...unavailableGroup, input_tokens: null, output_tokens: null };
-    const table = CostRunsTable({
-      rows: [unavailableRun] as never,
-      onOpenRun: () => undefined,
-      currency: "BRL",
-      locale: "pt-BR",
-    });
-    const columns = table.props.columns as Array<{
-      key: string;
-      sortValue?: (row: typeof unavailableGroup) => unknown;
-    }>;
-    const column = (key: string) => columns.find((candidate) => candidate.key === key);
-    expect(column("duration")?.sortValue?.(unavailableRun)).toBeNull();
-    expect(column("totalTokens")?.sortValue?.(unavailableRun)).toBeNull();
-    expect(column("cost")?.sortValue?.(unavailableRun)).toBeNull();
-  });
-  it("keeps missing invocation facts unavailable instead of presenting observed zero", () => {
-    const unavailableRun = {
-      ...unavailableGroup,
-      input_tokens: null,
-      cached_input_tokens: null,
-      uncached_input_tokens: null,
-      output_tokens: null,
-      reasoning_tokens: null,
-      visible_output_tokens: null,
-      input_rate_usd_per_million: null,
-      cached_input_rate_usd_per_million: null,
-      output_rate_usd_per_million: null,
-      reasoning_rate_usd_per_million: null,
-      context_input_multiplier: null,
-      context_output_multiplier: null,
-      input_cost_usd: null,
-      cached_input_cost_usd: null,
-      output_cost_usd: null,
-      reasoning_cost_usd: null,
-      standard_cost_usd: null,
-      speed_uplift_usd: null,
-      fx_rate: null,
-      recorded_fx_rate: null,
-      recorded_brl: null,
-      estimated_usd: null,
-      estimated_brl: null,
-    } as never;
-    const table = CostRunsTable({
-      rows: [unavailableRun],
-      onOpenRun: () => undefined,
-      currency: "BRL",
-      locale: "pt-BR",
-    });
-    const columns = table.props.columns as Array<{
-      key: string;
-      description?: string;
-      hidden?: boolean;
-      render?: (row: typeof unavailableRun) => unknown;
-    }>;
-    const column = (key: string) => columns.find((candidate) => candidate.key === key);
-    const numericKeys = [
-      "duration",
-      "inputTokens",
-      "cachedInputTokens",
-      "outputTokens",
-      "reasoningTokens",
-      "totalTokens",
-      "inputRate",
-      "cacheRate",
-      "outputRate",
-      "reasoningRate",
-      "contextMultiplier",
-      "inputCost",
-      "cacheCost",
-      "outputCost",
-      "reasoningCost",
-      "standardCost",
-      "speedUplift",
-      "finalUsd",
-      "fxRate",
-      "recordedFxRate",
-      "recordedBrl",
-      "cost",
-    ];
-    for (const key of numericKeys) {
-      expect(column(key)?.description).toContain("projeção SQLite/API");
-      expect(column(key)?.hidden).not.toBe(true);
-    }
-    expect(column("duration")?.render?.(unavailableRun)).toBe("Indisponível");
-    expect(column("inputTokens")?.render?.(unavailableRun)).toBe("0");
-    expect(column("inputRate")?.render?.(unavailableRun)).toBe("0,00");
-    expect(column("contextMultiplier")?.render?.(unavailableRun)).toBe("Indisponível");
-    expect(column("inputCost")?.render?.(unavailableRun)).toContain("0,00");
-    expect(column("fxRate")?.render?.(unavailableRun)).toBe("R$ 0,00");
-    expect(column("recordedBrl")?.render?.(unavailableRun)).toBe("Indisponível");
-    expect(column("cost")?.render?.(unavailableRun)).toBe("Indisponível");
-  });
-  it("provides a clear scroll label for the detailed Runs table", () => {
-    expect(costRunsScrollLabel("pt-BR")).toBe(
-      "Tabela de custos por invocação com rolagem horizontal",
-    );
-  });
-  it("presents inclusive input/output totals and only their cache/reasoning subsets", () => {
-    const run = {
-      ...unavailableGroup,
-      input_tokens: 1_000,
-      cached_input_tokens: 200,
-      output_tokens: 500,
-      reasoning_tokens: 100,
-      total_tokens: 1_700,
-    } as never;
-    const table = CostRunsTable({
-      rows: [run],
-      onOpenRun: () => undefined,
-      currency: "BRL",
-      locale: "pt-BR",
-    });
-    const columns = table.props.columns as Array<{
-      key: string;
-      label?: string;
-      sortValue?: (row: typeof run) => unknown;
-    }>;
-    const column = (key: string) => columns.find((candidate) => candidate.key === key);
-
-    expect(column("inputTokens")?.label).toBe("Input total");
-    expect(column("outputTokens")?.label).toBe("Output total");
-    expect(column("uncachedInputTokens")).toBeUndefined();
-    expect(column("visibleOutputTokens")).toBeUndefined();
-    expect(column("totalTokens")?.sortValue?.(run)).toBe(1_500);
-  });
-  it("uses server pagination without re-applying the visual 100-row truncation", () => {
-    const table = CostRunsTable({
-      rows: [unavailableGroup] as never,
-      onOpenRun: () => undefined,
-      currency: "BRL",
-      locale: "pt-BR",
-      pagination: {
-        offset: 100,
-        limit: 100,
-        total: 250,
-        has_more: true,
-        loading: false,
-        error: null,
-        onChange: () => undefined,
-        onRetry: () => undefined,
-      },
-    });
-    expect(table.type).toBe(Symbol.for("react.fragment"));
-    expect(table.props.children[0].props.pageSize).toBeNull();
-  });
-  it("keeps an initial server-page error actionable before a page exists", () => {
-    const table = CostRunsTable({
-      rows: [unavailableGroup] as never,
-      onOpenRun: () => undefined,
-      currency: "BRL",
-      locale: "pt-BR",
-      pagination: {
-        offset: 0,
-        limit: 100,
-        total: 1,
-        has_more: false,
-        loading: false,
-        error: "network failed",
-        onChange: () => undefined,
-        onRetry: () => undefined,
-      },
-    });
-    const pager = table.props.children[1];
-    expect(pager.props.pagination.error).toBe("network failed");
-    expect(pager.props.pagination.onRetry).toEqual(expect.any(Function));
-  });
-});
-describe("cost sorting", () => {
-  it("orders the raw BRL values rather than their localized currency labels", () => {
-    const rows = [143.72, 127.78, 21457.76, 1370.63];
-    expect(
-      rows.sort(
-        (left, right) =>
-          (sortCostValue("BRL", right, null) ?? 0) - (sortCostValue("BRL", left, null) ?? 0),
-      ),
-    ).toEqual([21457.76, 1370.63, 143.72, 127.78]);
-  });
-});
-describe("context uplift", () => {
-  const base = {
-    context_input_multiplier: 1,
-    context_output_multiplier: 1,
-    input_cost_usd: 10,
-    cached_input_cost_usd: 2,
-    output_cost_usd: 8,
-    reasoning_cost_usd: 2,
-  };
-  it("returns zero for a 1x / 1x call", () => {
-    expect(contextUpliftUsd(base as never)).toBe(0);
-  });
-  it("extracts the already included context portion from effective costs", () => {
-    expect(
-      contextUpliftUsd({
-        ...base,
-        context_input_multiplier: 2,
-        context_output_multiplier: 1.5,
-      } as never),
-    ).toBeCloseTo(9.333333, 5);
-  });
-});
-describe("model aggregation visibility", () => {
-  it("hides the manual placeholder regardless of casing or whitespace", () => {
-    expect(isDisplayableModel("manual")).toBe(false);
-    expect(isDisplayableModel(" Manual ")).toBe(false);
-    expect(isDisplayableModel("unknown")).toBe(false);
-    expect(isDisplayableModel(" ")).toBe(false);
-    expect(isDisplayableModel("gpt-5")).toBe(false);
-    expect(isDisplayableModel(" GPT-5 ")).toBe(false);
-    expect(isDisplayableModel("gpt-5.4")).toBe(true);
-    expect(isDisplayableModel("gpt-5.6-sol")).toBe(true);
-  });
-  it("hides calls that have no collected usage", () => {
-    const empty = {
-      input_tokens: null,
-      cached_input_tokens: null,
-      output_tokens: null,
-      reasoning_tokens: null,
-      total_tokens: null,
-      estimated_usd: null,
-      estimated_brl: null,
-    };
-    expect(hasCollectedUsage(empty as never)).toBe(false);
-    expect(hasCollectedUsage({ ...empty, input_tokens: 1 } as never)).toBe(true);
-    expect(hasCollectedUsage({ ...empty, estimated_brl: 0.01 } as never)).toBe(true);
-  });
-});
-describe("model processing duration", () => {
-  it("sums root orchestration Runs without overlapping intake and Sub-Runs", () => {
-    expect(
-      sumModelDurationMs([
-        { duration_ms: 60_000, run_kind: "run", run_purpose: "orchestration" },
-        { duration_ms: 90_000, run_kind: "subrun", run_purpose: "execution" },
-        { duration_ms: 120_000, run_kind: "run", run_purpose: "intake" },
-        { duration_ms: 30_000, run_kind: "run", run_purpose: "orchestration" },
-      ]),
-    ).toBe(300_000);
-    expect(
-      sumModelDurationMs([
-        { duration_ms: 90_000, run_kind: "subrun", run_purpose: "execution" },
-        { duration_ms: 120_000, run_kind: "run", run_purpose: "intake" },
-      ]),
-    ).toBe(210_000);
-  });
-  it("groups Runs without an identifiable model as unavailable", () => {
-    expect(displayModelName("gpt-5.6-sol", "pt-BR")).toBe("gpt-5.6-sol");
-    expect(displayModelName("unknown", "pt-BR")).toBe("Indisponível");
-    expect(displayModelName(" ", "en-US")).toBe("Unavailable");
-    expect(displayModelName("manual", "pt-BR")).toBeNull();
-    expect(displayModelName("gpt-5", "pt-BR")).toBeNull();
-  });
-  it("presents genuinely missing aggregate dimensions as unavailable", () => {
-    expect(displayCostGroupLabel("unknown", "pt-BR")).toBe("Sem modelo/provedor atribuído");
-    expect(displayCostGroupLabel(" ", "en-US")).toBe("No model/provider assigned");
-    expect(displayCostGroupLabel("gpt-5.6-sol", "pt-BR")).toBe("gpt-5.6-sol");
-  });
-  it("keeps duration-only root orchestration Runs in the model table", () => {
-    expect(
-      isModelAuditRow({
-        duration_ms: 90_000,
-        run_kind: "run",
-        run_purpose: "orchestration",
-        input_tokens: null,
-        cached_input_tokens: null,
-        output_tokens: null,
-        reasoning_tokens: null,
-        total_tokens: null,
-        estimated_usd: null,
-        estimated_brl: null,
-      } as never),
-    ).toBe(true);
-    expect(
-      isModelAuditRow({
-        duration_ms: 90_000,
-        run_kind: "subrun",
-        run_purpose: "execution",
-        input_tokens: null,
-        cached_input_tokens: null,
-        output_tokens: null,
-        reasoning_tokens: null,
-        total_tokens: null,
-        estimated_usd: null,
-        estimated_brl: null,
-      } as never),
-    ).toBe(true);
-  });
 });