@zaip-ai/cli 1.0.8 → 1.3.1

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

@@ -1,17 +1,11 @@
 import { createHash } from "node:crypto";
 import { queryInvocationManifestPeriod } from "@zaip-ai/costs";
 import { describe, expect, it } from "vitest";
-import {
-  activeCostPeriodData,
-  costPeriodDateRange,
-  defaultCostPeriod,
-  emptyCostFilters,
-  loadCostMonitorPeriod,
-  shouldFetchCostPeriod,
-} from "./CostFilters.js";
 import { displayModelName, isModelAuditRow, sumModelDurationMs } from "./CostModelsAuditTable.js";
 import {
   agentRunModelPresentation,
+  type CostDeveloperAttributionRow,
+  CostDeveloperAttributionTable,
   CostGroupsTable,
   CostRunsTable,
   contextUpliftUsd,
@@ -29,7 +23,6 @@ import {
   formatCostPeriodLabel,
   formatDateTime,
   formatDurationCoverage,
-  formatMultiplierPair,
   formatRate,
   formatReasoningEffort,
   formatServiceTier,
@@ -207,6 +200,112 @@ describe("runtime availability", () => {
   });
 });
 describe("grouped cost availability", () => {
+  it("uses the requested Cost Monitor developer metric columns without Operations source or coverage", () => {
+    const table = CostDeveloperAttributionTable({
+      locale: "pt-BR",
+      rows: [
+        {
+          account_id: "42",
+          login_snapshot: "dev-42",
+          prd_count: 1,
+          spec_count: 2,
+          task_count: 3,
+          run_count: 4,
+          test_count: null,
+          evidence_count: null,
+          total_duration_ms: 60_000,
+          total_tokens: 50,
+          total_cost_brl: 1.5,
+          duration_covered_runs: 4,
+          token_covered_runs: 4,
+          brl_covered_runs: 4,
+        },
+      ],
+    });
+    const columns = table.props.columns as Array<{
+      key: string;
+      label: string;
+      render: (row: CostDeveloperAttributionRow) => unknown;
+    }>;
+    const unavailable = {
+      account_id: "unknown",
+      login_snapshot: null,
+      prd_count: 0,
+      spec_count: 0,
+      task_count: 0,
+      run_count: 0,
+      test_count: null,
+      evidence_count: null,
+      total_duration_ms: null,
+      total_tokens: null,
+      total_cost_brl: null,
+      duration_covered_runs: 0,
+      token_covered_runs: 0,
+      brl_covered_runs: 0,
+    } satisfies CostDeveloperAttributionRow;
+    expect(columns.map((column) => [column.key, column.label])).toEqual([
+      ["developer", "Desenvolvedor"],
+      ["prds", "PRDs"],
+      ["specs", "SPECs"],
+      ["tasks", "Tarefas"],
+      ["runs", "Runs"],
+      ["tests", "Testes"],
+      ["evidences", "Evidências"],
+      ["duration", "Tempo"],
+      ["tokens", "Tokens"],
+      ["cost", "Custos"],
+    ]);
+    expect(columns.find((column) => column.key === "tests")?.render(unavailable)).toBe("—");
+    expect(columns.find((column) => column.key === "evidences")?.render(unavailable)).toBe("—");
+    expect(columns.find((column) => column.key === "duration")?.render(unavailable)).toBe(
+      "Indisponível",
+    );
+  });
+  it("marks incomplete aggregates in place without adding source or coverage columns", () => {
+    const partial = {
+      account_id: "42",
+      login_snapshot: "dev-42",
+      prd_count: 1,
+      spec_count: 2,
+      task_count: 3,
+      run_count: 4,
+      test_count: null,
+      evidence_count: null,
+      total_duration_ms: 60_000,
+      total_tokens: 50,
+      total_cost_brl: 1.5,
+      duration_covered_runs: 3,
+      token_covered_runs: 2,
+      brl_covered_runs: 2,
+    } satisfies CostDeveloperAttributionRow;
+    const table = CostDeveloperAttributionTable({ locale: "pt-BR", rows: [partial] });
+    const columns = table.props.columns as Array<{
+      key: string;
+      render: (
+        row: CostDeveloperAttributionRow,
+      ) => { props?: { children?: unknown[]; title?: string } } | string;
+    }>;
+    for (const key of ["duration", "tokens", "cost"]) {
+      const rendered = columns.find((column) => column.key === key)?.render(partial);
+      expect(rendered).toMatchObject({
+        props: {
+          title: expect.stringContaining("Valor parcial"),
+        },
+      });
+      const children = (rendered as { props: { children: unknown[] } }).props.children;
+      expect(children[0]).toMatchObject({
+        props: { "aria-hidden": "true", children: expect.any(String) },
+      });
+      expect(children[1]).toMatchObject({
+        props: { children: expect.stringContaining("Valor parcial") },
+      });
+      expect(
+        (rendered as { props: { "aria-label"?: string } }).props["aria-label"],
+      ).toBeUndefined();
+    }
+    expect(columns.map((column) => column.key)).not.toContain("coverage");
+    expect(columns.map((column) => column.key)).not.toContain("source");
+  });
   it("uses deduplicated root and child invocation effort in the Run drilldown footer", () => {
     const root = {
       run_id: "RUN-ROOT",
@@ -290,22 +389,28 @@ describe("grouped cost availability", () => {
     expect(column("tokens")?.sortValue?.(unavailableGroup)).toBeNull();
     expect(column("cost")?.sortValue?.(unavailableGroup)).toBeNull();
     const totalSummary = "Total geral — Tempo: Indisponível; Tokens: 0; BRL: R$ 0,00";
-    expect(
-      (column("latestStartedAt")!.footer as { props: { "aria-label": string } }).props[
-        "aria-label"
-      ],
-    ).toBe("Total geral");
-    expect(
-      (column("duration")!.footer as { props: { "aria-label": string } }).props["aria-label"],
-    ).toBe(totalSummary);
-    expect(
-      (column("tokens")!.footer as { props: { "aria-label": string } }).props["aria-label"],
-    ).toBe(totalSummary);
-    expect(
-      (column("cost")!.footer as { props: { "aria-label": string } }).props["aria-label"],
-    ).toBe(totalSummary);
+    const footerLabel = (key: string) => {
+      const footer = column(key)?.footer as { props?: { "aria-label"?: string } } | undefined;
+      return footer?.props?.["aria-label"];
+    };
+    expect(footerLabel("latestStartedAt")).toBe("Total geral");
+    expect(footerLabel("duration")).toBe(totalSummary);
+    expect(footerLabel("tokens")).toBe(totalSummary);
+    expect(footerLabel("cost")).toBe(totalSummary);
     expect(column("coverage")).toBeUndefined();
   });
+  it("keeps the empty state until loading settles for local cost-group pages", () => {
+    const loadingTable = CostGroupsTable({
+      rows: [],
+      currency: "BRL",
+      locale: "pt-BR",
+      loading: true,
+    });
+    const emptyTable = CostGroupsTable({ rows: [], currency: "BRL", locale: "pt-BR" });
+
+    expect(loadingTable.props.emptyMessage).toBe("Carregando…");
+    expect(emptyTable.props.emptyMessage).toBe("Nenhum dado disponível.");
+  });
   it("uses supplied pre-pagination totals for daily footer metrics", () => {
     const table = CostGroupsTable({
       rows: [{ ...unavailableGroup, total_tokens: 5, estimated_brl: 2, estimated_usd: 1 }],
@@ -321,26 +426,58 @@ describe("grouped cost availability", () => {
       },
     });
     const columns = table.props.columns as Array<{ key: string; footer?: unknown }>;
-    expect((columns.find((column) => column.key === "tokens")?.footer as { props: { children: unknown } }).props.children).toBe("50");
-    expect((columns.find((column) => column.key === "cost")?.footer as { props: { children: unknown } }).props.children).toContain("20,00");
+    const tokenFooter = columns.find((column) => column.key === "tokens")?.footer;
+    const costFooter = columns.find((column) => column.key === "cost")?.footer;
+    expect(tokenFooter).toBeDefined();
+    expect(costFooter).toBeDefined();
+    expect((tokenFooter as { props: { children: unknown } }).props.children).toBe("50");
+    expect((costFooter as { props: { children: unknown } }).props.children).toContain("20,00");
   });
   it("renders ZAIP agent identity without a synthetic date column", () => {
     const table = CostGroupsTable({
-      rows: [{ ...unavailableGroup, key: "zaip-agent-builder", label: "zaip-agent-builder", persona: "Rafa", job: "Builder" }],
+      rows: [
+        {
+          ...unavailableGroup,
+          key: "zaip-agent-builder",
+          label: "zaip-agent-builder",
+          persona: "Rafa",
+          job: "Builder",
+        },
+      ],
       currency: "BRL",
       locale: "pt-BR",
       showDateTime: false,
       showAgentIdentity: true,
     });
-    const columns = table.props.columns as Array<{ key: string; label: string; hidden?: boolean; render?: (row: { persona?: string | null; job?: string | null }) => unknown }>;
+    const columns = table.props.columns as Array<{
+      key: string;
+      label: string;
+      hidden?: boolean;
+      render?: (row: { persona?: string | null; job?: string | null }) => unknown;
+    }>;
     expect(columns.find((column) => column.key === "latestStartedAt")?.hidden).toBe(true);
-    expect(columns.find((column) => column.key === "persona")?.render?.({ persona: "Rafa" })).toBe("Rafa");
-    expect(columns.find((column) => column.key === "job")?.render?.({ job: "Builder" })).toBe("Builder");
+    expect(columns.find((column) => column.key === "persona")?.render?.({ persona: "Rafa" })).toBe(
+      "Rafa",
+    );
+    expect(columns.find((column) => column.key === "job")?.render?.({ job: "Builder" })).toBe(
+      "Builder",
+    );
     expect(columns.find((column) => column.key === "tasks")).toBeUndefined();
+    expect(table.props.defaultSort).toEqual({ key: "cost", direction: "desc" });
   });
   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 }],
+      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,
@@ -355,11 +492,19 @@ describe("grouped cost availability", () => {
         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("");
+    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);
-    expect((columns.find((column) => column.key === "tokens")?.footer as { props: { children: unknown } }).props.children).toBe("30");
+    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({
@@ -398,8 +543,9 @@ describe("grouped cost availability", () => {
       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");
+    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", () => {
@@ -470,11 +616,28 @@ describe("grouped cost availability", () => {
     }>;
     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",
+      "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");
@@ -564,121 +727,6 @@ describe("grouped cost availability", () => {
     expect(pager.props.pagination.onRetry).toEqual(expect.any(Function));
   });
 });
-describe("period-driven Cost Monitor loading", () => {
-  it("drops a stale in-memory Cost period response when refresh replaces its base snapshot", () => {
-    const stale = { runs: [{ run_id: "RUN-OBSERVED", duration_ms: 31 * 3_600_000 }] } as never;
-    const refreshed = { runs: [{ run_id: "RUN-PROJECTED", duration_ms: 413_659_026 }] } as never;
-    expect(activeCostPeriodData(refreshed, stale, stale)).toBe(refreshed);
-    expect(activeCostPeriodData(refreshed, refreshed, refreshed)).toBe(refreshed);
-  });
-  it("does not issue a second Cost request after an embedded default atomic snapshot", () => {
-    const filters = {
-      query: "",
-      provider: "",
-      phase: "",
-      origin: "",
-      workType: "",
-      agent: "",
-      model: "",
-      status: "",
-      priority: "",
-      risk: "",
-    };
-    expect(shouldFetchCostPeriod({ filters, period: "month", snapshotBacked: true })).toBe(false);
-    expect(shouldFetchCostPeriod({ filters, period: "all", snapshotBacked: true })).toBe(true);
-    expect(shouldFetchCostPeriod({ filters, period: "7", snapshotBacked: true })).toBe(true);
-    expect(
-      shouldFetchCostPeriod({
-        filters: { ...filters, phase: "execution" },
-        period: "month",
-        snapshotBacked: true,
-      }),
-    ).toBe(true);
-  });
-  it("uses the current month for the default period and keeps All Time explicit", async () => {
-    expect(defaultCostPeriod).toBe("month");
-    expect(costPeriodDateRange("all", new Date("2026-08-01T03:30:00.000Z"))).toBeUndefined();
-    expect(costPeriodDateRange("month", new Date("2026-08-01T03:30:00.000Z"))).toEqual({
-      from: "2026-08-01",
-      to: "2026-08-01",
-    });
-    // Selecting standalone All Time still removes the prior month bounds.
-    expect(costPeriodDateRange("all", new Date("2026-08-01T03:30:00.000Z"))).toBeUndefined();
-    const calls: string[] = [];
-    await loadCostMonitorPeriod({
-      currency: "BRL",
-      fetcher: async (url) => {
-        calls.push(String(url));
-        return new Response(JSON.stringify({ runs: [] }), { status: 200 });
-      },
-    });
-    expect(calls).toEqual(["/api/v2/cost-monitor?currency=BRL&scope=summary"]);
-  });
-  it("derives an inclusive current-month range without inspecting materialized Runs", () => {
-    expect(costPeriodDateRange("month", new Date("2026-07-26T15:00:00.000Z"))).toEqual({
-      from: "2026-07-01",
-      to: "2026-07-26",
-    });
-    expect(costPeriodDateRange("7", new Date("2026-07-26T15:00:00.000Z"))).toEqual({
-      from: "2026-07-20",
-      to: "2026-07-26",
-    });
-  });
-  it("requests the selected range from the local runtime and forwards cancellation", async () => {
-    const calls: Array<{ url: string; signal: AbortSignal | null | undefined }> = [];
-    const controller = new AbortController();
-    const projection = { runs: [] };
-    const loaded = await loadCostMonitorPeriod({
-      currency: "BRL",
-      from: "2026-07-01",
-      to: "2026-07-26",
-      filters: {
-        query: "TASK-1",
-        provider: "openai",
-        phase: "execution",
-        origin: "spec",
-        workType: "rework",
-        agent: "zaip-agent-builder",
-        model: "gpt-5.6-terra",
-        status: "completed",
-        priority: "high",
-        risk: "standard",
-      },
-      signal: controller.signal,
-      fetcher: async (url, init) => {
-        calls.push({ url: String(url), signal: init?.signal });
-        return new Response(JSON.stringify(projection), {
-          headers: { "content-type": "application/json" },
-          status: 200,
-        });
-      },
-    });
-    expect(loaded).toEqual(projection);
-    expect(calls).toEqual([
-      {
-        url:
-          "/api/v2/cost-monitor?currency=BRL&scope=summary&from=2026-07-01&to=2026-07-26" +
-          "&provider=openai&phase=execution&agent=zaip-agent-builder" +
-          "&model=gpt-5.6-terra&status=completed",
-        signal: controller.signal,
-      },
-    ]);
-  });
-  it("never leaves period/filter hydration scope-less or on detail", async () => {
-    const calls: string[] = [];
-    await loadCostMonitorPeriod({
-      currency: "USD",
-      filters: { ...emptyCostFilters, provider: "openai", model: "gpt-5.6-terra" },
-      fetcher: async (url) => {
-        calls.push(String(url));
-        return new Response(JSON.stringify({ runs: [] }), { status: 200 });
-      },
-    });
-    const request = new URL(calls[0]!, "http://dashboard.local");
-    expect(request.searchParams.get("scope")).toBe("summary");
-    expect(request.searchParams.get("scope")).not.toBe("detail");
-  });
-});
 describe("manifest-first invocation query", () => {
   it("opens only intersecting monthly manifests and candidate chunks", async () => {
     const inRange = signedSummary({