@zaip-ai/cli 1.0.7 → 1.3.0

package/templates/.agents/dashboard/apps/frontend/src/cost-calculation-guide.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+import { calculateGuideCost, calculateLongContextGuideCost } from "./CostCalculationGuidePage.js";
+
+const model = {
+  id: "example",
+  provider: "openai" as const,
+  aliases: [],
+  input_per_million_usd: 2,
+  cached_input_per_million_usd: 0.5,
+  output_per_million_usd: 8,
+  reasoning_per_million_usd: 99,
+  priority_input_per_million_usd: 4,
+  priority_cached_input_per_million_usd: 1,
+  priority_output_per_million_usd: 16,
+  priority_reasoning_per_million_usd: 99,
+  reasoning_billed_separately: false,
+  long_context_threshold_tokens: 128000,
+  long_context_input_multiplier: 2,
+  long_context_output_multiplier: 1.5,
+  source_label: "test",
+  source_url: "",
+  notes: [],
+};
+
+describe("cost calculation guide math", () => {
+  it("does not charge cache or reasoning twice", () => {
+    const result = calculateGuideCost(model, "standard", 5);
+    expect(result).toMatchObject({
+      inputUsd: 0.12,
+      cacheUsd: 0.02,
+      outputUsd: 0.16,
+      reasoningUsd: 0,
+      totalUsd: 0.3,
+      totalBrl: 1.5,
+    });
+  });
+  it("keeps BRL unavailable without FX", () =>
+    expect(calculateGuideCost(model, "standard", null)?.totalBrl).toBeNull());
+  it("keeps Priority unavailable when its required rates are not published", () =>
+    expect(
+      calculateGuideCost({ ...model, priority_input_per_million_usd: null }, "priority", 5),
+    ).toBeNull());
+  it("treats an unpublished cache rate as zero, matching pricing-math", () => {
+    const result = calculateGuideCost(
+      { ...model, cached_input_per_million_usd: null },
+      "standard",
+      5,
+    );
+    expect(result).toMatchObject({ cacheUsd: 0, totalUsd: 0.28 });
+  });
+  it("does not require a separate Priority cache rate", () => {
+    const result = calculateGuideCost(
+      { ...model, priority_cached_input_per_million_usd: null },
+      "priority",
+      5,
+    );
+    expect(result).toMatchObject({ cacheUsd: 0, totalUsd: 0.56 });
+  });
+  it("uses threshold plus 50k and applies long-context multipliers to input, cache and output", () => {
+    const result = calculateLongContextGuideCost(model, 5);
+    expect(result).toMatchObject({ inputUsd: 0.552, cacheUsd: 0.04, outputUsd: 0.24 });
+    expect(result?.totalUsd).toBeCloseTo(0.832);
+  });
+  it("keeps long context unavailable when the model has no threshold", () => {
+    expect(
+      calculateLongContextGuideCost({ ...model, long_context_threshold_tokens: null }, 5),
+    ).toBeNull();
+  });
+});

package/templates/.agents/dashboard/apps/frontend/src/cost-period-refresh.test.ts

@@ -0,0 +1,85 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { isCurrentDashboardRequest, needsAtomicCostSnapshot } from "./App.js";
+
+describe("Cost period refresh", () => {
+  it("does not retain a prior Cost Monitor snapshot while Todo o Período is loading", () => {
+    const priorSnapshot = { generation: 1, period: "this-month" };
+    let renderedSnapshot: typeof priorSnapshot | null = priorSnapshot;
+    let exportedSnapshot: typeof priorSnapshot | null = priorSnapshot;
+
+    renderedSnapshot = null;
+    exportedSnapshot = null;
+
+    expect(needsAtomicCostSnapshot("cost-monitor", false)).toBe(false);
+    expect(renderedSnapshot).toBeNull();
+    expect(exportedSnapshot).toBeNull();
+  });
+
+  it("mounts Cost from a Daily seed without a full summary request", () => {
+    const app = readFileSync(new URL("./App.tsx", import.meta.url), "utf8");
+    const refresh = app.slice(
+      app.indexOf("const refresh = useCallback"),
+      app.indexOf("const loadOperationsDetails"),
+    );
+    const compactRefresh = refresh.replace(/\s+/g, " ");
+
+    expect(refresh).not.toContain("dailyCostSeed(currency, period)");
+    expect(refresh).toContain("initialAggregateFreshRef.current");
+    expect(refresh).not.toContain("loadAtomicCostSnapshot(() => api.snapshot(currency, period))");
+    expect(refresh).toContain(
+      'api.operations(period, "quick", undefined, initialAggregateFreshRef.current)',
+    );
+    expect(compactRefresh).toContain(
+      'currency === "USD" ? api.costMonitor(currency, period, "summary") : Promise.resolve(null)',
+    );
+    expect(refresh).toContain("setDisplayedCosts(null);");
+    expect(refresh).toContain("const activeDashboardView = dashboardViewRef.current");
+    expect(refresh).toContain("[api, currency, operationsPeriod]");
+    expect(refresh).not.toContain("[api, currency, dashboardView, operationsPeriod]");
+  });
+
+  it("keeps the replacement snapshot when a prior-period details request resolves late", () => {
+    let refreshVersion = 3;
+    const priorRequestVersion = refreshVersion;
+    const activeExport = { generation: 3, period: "this-month" };
+
+    refreshVersion += 1;
+    const latePriorResponseIsCurrent = isCurrentDashboardRequest(
+      priorRequestVersion,
+      refreshVersion,
+    );
+
+    expect(latePriorResponseIsCurrent).toBe(false);
+    expect(activeExport).toEqual({ generation: 3, period: "this-month" });
+  });
+
+  it("connects SQLite run and filtered group pagers through App", () => {
+    const app = readFileSync(new URL("./App.tsx", import.meta.url), "utf8");
+    const loaders = readFileSync(new URL("./use-app-cost-loaders.ts", import.meta.url), "utf8");
+    expect(app).toContain("useAppCostLoaders(api)");
+    expect(loaders).toContain("const loadCostRunPage = useCallback<LoadCostRunPage>");
+    expect(loaders).toMatch(/api\.sqliteViewPage\(\s*"cost_monitor_agent_invocations"/);
+    expect(loaders).toContain("const loadCostGroupPage = useCallback<LoadCostGroupPage>");
+    expect(loaders).toContain("task_count: nullableSqlNumber(row.task_count)");
+    expect(loaders).toContain("prd_count: Number(row.prd_count ?? 0)");
+    expect(loaders).toContain("spec_count: Number(row.spec_count ?? 0)");
+    expect(loaders).toContain("evidence_count: Number(row.evidence_count ?? 0)");
+    expect(loaders).toContain("test_count: Number(row.validation_count ?? 0)");
+    for (const dimension of [
+      "provider",
+      "model",
+      "agent",
+      "phase",
+      "status",
+      "origin",
+      "workType",
+      "priority",
+      "risk",
+    ])
+      expect(loaders).toContain(`filters.${dimension}`);
+    expect(app).toContain("loadRunPage={loadCostRunPage}");
+    expect(app).toContain("loadReadModelPage={loadCostReadModelPage}");
+    expect(app).toContain("loadDetail={loadCostDetail}");
+  });
+});

package/templates/.agents/dashboard/apps/frontend/src/dashboard-api.test.ts

@@ -28,4 +28,137 @@ describe("DashboardApiClient reconciliation", () => {
     await vi.advanceTimersByTimeAsync(reconciliationRequestTimeoutMs - 30_000);
     await rejection;
   });
+
+  it("posts to the exact canonical reconciliation path without a trailing slash", async () => {
+    vi.stubGlobal("window", globalThis);
+    const fetchMock = vi.fn(
+      async () =>
+        new Response(
+          JSON.stringify({
+            reconciliation: { reconciled_ids: [], blocked: [], not_reconciled: [] },
+          }),
+          { status: 200 },
+        ),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+
+    await new DashboardApiClient("session").reconcileOpenWork("BRL", {
+      from: "2026-08-12",
+      to: "2026-08-12",
+    });
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      "/api/v2/reconcile-open-work?currency=BRL&from=2026-08-12&to=2026-08-12",
+      expect.objectContaining({ method: "POST", headers: { "x-zaip-session": "session" } }),
+    );
+  });
+
+  it("refreshes the disposable projection without calling the reconciliation route", async () => {
+    vi.stubGlobal("window", globalThis);
+    const fetchMock = vi.fn(async () => new Response(JSON.stringify({}), { status: 200 }));
+    vi.stubGlobal("fetch", fetchMock);
+
+    await new DashboardApiClient("session").refreshProjection("BRL", {
+      from: "2026-08-12",
+      to: "2026-08-12",
+    });
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      "/api/v2/refresh-projection?currency=BRL&from=2026-08-12&to=2026-08-12",
+      expect.objectContaining({ method: "POST", headers: { "x-zaip-session": "session" } }),
+    );
+  });
+});
+
+describe("DashboardApiClient cost monitor", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("serializes every supported SQLite lazy-view filter", async () => {
+    vi.stubGlobal("window", globalThis);
+    const fetchMock = vi.fn((_path: string) =>
+      Promise.resolve(
+        new Response(JSON.stringify({ runs: [] }), {
+          headers: { "content-type": "application/json" },
+          status: 200,
+        }),
+      ),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+
+    await new DashboardApiClient("session").sqliteViewPage(
+      "cost_monitor_agent_invocations",
+      { from: "2026-08-01", to: "2026-08-08" },
+      {
+        limit: 100,
+        query: "edge",
+        provider: "openai",
+        model: "gpt-5",
+        agent: "agent-a",
+        phase: "execution",
+        status: "completed",
+      },
+    );
+
+    const requestPath = String(fetchMock.mock.calls[0]?.[0]);
+    for (const value of [
+      "query=edge",
+      "provider=openai",
+      "model=gpt-5",
+      "agent=agent-a",
+      "phase=execution",
+      "status=completed",
+      "from=2026-08-01",
+      "to=2026-08-08",
+    ])
+      expect(requestPath).toContain(value);
+    expect(requestPath).not.toContain("run_kind=");
+  });
+
+  it("adds fresh only to an explicit bootstrap aggregate read", async () => {
+    vi.stubGlobal("window", globalThis);
+    const fetchMock = vi.fn((_path: string | URL | Request) =>
+      Promise.resolve(new Response("{}", { status: 200 })),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+    const client = new DashboardApiClient("session");
+    await client.operations(undefined, "quick", undefined, true);
+    await client.costMonitor("BRL", undefined, "summary", undefined, undefined, true);
+    await client.operations(undefined, "quick");
+    const paths = fetchMock.mock.calls.map(([path]) => String(path));
+    expect(paths[0]).toContain("fresh=1");
+    expect(paths[1]).toContain("fresh=1");
+    expect(paths[2]).not.toContain("fresh=1");
+  });
+
+  it("loads dimensional detail through the authenticated client with filters and cancellation", async () => {
+    vi.stubGlobal("window", globalThis);
+    const fetchMock = vi.fn((_path: string, _init?: RequestInit) =>
+      Promise.resolve(
+        new Response(JSON.stringify({ runs: [] }), {
+          headers: { "content-type": "application/json" },
+          status: 200,
+        }),
+      ),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+    const controller = new AbortController();
+
+    await new DashboardApiClient("session").costMonitor(
+      "BRL",
+      { from: "2026-08-07", to: "2026-08-07" },
+      "detail",
+      controller.signal,
+      { agent: "zaip-agent-builder", model: "gpt-5.6-terra" },
+    );
+
+    const requestPath = String(fetchMock.mock.calls[0]?.[0]);
+    const requestInit = fetchMock.mock.calls[0]?.[1];
+    expect(requestPath).toContain("scope=detail");
+    expect(requestPath).toContain("agent=zaip-agent-builder");
+    expect(requestPath).toContain("model=gpt-5.6-terra");
+    expect(requestInit?.headers).toEqual({ "x-zaip-session": "session" });
+    expect(requestInit?.signal).toBeInstanceOf(AbortSignal);
+  });
 });