@zaip-ai/cli 2.2.0 → 3.0.0

package/templates/.agents/dashboard/modules/cost-monitor/src/react/CostTables-hides-calls-that-have-no-collected.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from "vitest";
+import { displayModelName, isModelAuditRow, sumModelDurationMs } from "./CostModelsAuditTable.js";
+import { displayCostGroupLabel, hasCollectedUsage } from "./CostTables.js";
+
+describe("model aggregation visibility", () => {
+  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);
+  });
+});

package/templates/.agents/dashboard/modules/cost-monitor/src/react/CostTables-keeps-legacy-codex-identity-fields-blank.test.ts

@@ -0,0 +1,455 @@
+import { describe, expect, it } from "vitest";
+import type { CostGroupRow } from "../contracts.js";
+import {
+  CostGroupsTable,
+  CostRunsTable,
+  contextUpliftUsd,
+  costRunsScrollLabel,
+  formatAuditableDuration,
+  isDisplayableModel,
+  sortCostValue,
+} from "./CostTables.js";
+
+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("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);
+  });
+});