@zaip-ai/cli 1.0.4 → 1.0.7

package/templates/.agents/dashboard/modules/operations/src/react/OperationsOverview.test.ts

@@ -0,0 +1,498 @@
+import { describe, expect, it } from "vitest";
+import {
+  allPhaseMetricTotals,
+  executionMetricTotals,
+  operationalRootExecutionDuration,
+} from "./execution-metrics.js";
+import {
+  aggregateMacroMetrics,
+  aggregateTaskMetrics,
+  averageObserved,
+  countExecutionDays,
+  findLatestCreatedAt,
+  findLatestTaskCreatedAt,
+  formatExecutionAverageHint,
+  formatTokenThroughputHint,
+  macroClassificationStats,
+  macroStatusDistribution,
+  overviewText,
+  statusColors,
+  summarizeTopEntityMetrics,
+  summarizeTopTaskMetrics,
+  taskStatusDistribution,
+} from "./OperationsOverview.js";
+
+describe("global card population", () => {
+  it("includes conversation and planning usage but excludes them from duration", () => {
+    const runs = [
+      { ...run("TASK-1", 100, 10, 1), source_duration_ms: 100 },
+      { ...run("TASK-1", 9_000, 20, 2), id: "RUN-CONVERSATION", phase: "conversation" },
+      { ...run("TASK-1", 8_000, 30, 3), id: "RUN-PLANNING", phase: "planning" },
+    ];
+    expect(executionMetricTotals(runs)).toMatchObject({ durationMs: 100, tokens: 10, costBrl: 1 });
+    expect(allPhaseMetricTotals(runs)).toMatchObject({ tokens: 60, costBrl: 6 });
+  });
+
+  it("uses the same observed execution population as period tables, never lifecycle elapsed time", () => {
+    const root = {
+      ...run("TASK-1", 100, 10, 1),
+      id: "RUN-ROOT",
+      duration_ms: null,
+      source_duration_ms: null,
+      started_at: "2026-07-28T10:00:00.000Z",
+      finished_at: "2026-07-31T09:09:21.600Z",
+    };
+    const child = {
+      ...run("TASK-1", 7_200_000, 20, 2),
+      id: "RUN-CHILD",
+      parent_run_id: root.id,
+      source_duration_ms: 7_200_000,
+    };
+
+    expect(operationalRootExecutionDuration([root, child])).toBeNull();
+    expect(executionMetricTotals([root, child])).toMatchObject({ durationMs: null });
+  });
+
+  it("sums deduplicated observed root and Sub-Run duration, excluding estimated or absent telemetry", () => {
+    const root = {
+      ...run("TASK-1", 99, 1, 1),
+      id: "RUN-ROOT-OBS",
+      source_duration_ms: 4 * 3_600_000,
+    };
+    const child = {
+      ...run("TASK-1", 99, 1, 1),
+      id: "RUN-CHILD-OBS",
+      parent_run_id: root.id,
+      source_duration_ms: 3 * 3_600_000,
+    };
+    const estimated = {
+      ...run("TASK-1", 60_000, 1, 1),
+      id: "RUN-ESTIMATED",
+      duration_ms: 60_000,
+      source_duration_ms: null,
+    };
+    const totals = executionMetricTotals([root, child, child, estimated]);
+    expect(totals.durationMs).toBe(4 * 3_600_000);
+    expect(totals.runs.map((run) => run.id)).toEqual(["RUN-ROOT-OBS", "RUN-ESTIMATED"]);
+  });
+
+  it("uses observed source duration instead of a projected duration", () => {
+    const staleObserved = {
+      ...run("TASK-1", 413_659_026, 10, 1),
+      id: "RUN-PROJECTED",
+      source_duration_ms: 31 * 3_600_000,
+    };
+
+    expect(executionMetricTotals([staleObserved])).toMatchObject({
+      durationMs: 31 * 3_600_000,
+      tokens: 10,
+      costBrl: 1,
+    });
+  });
+});
+
+describe("execution average summary", () => {
+  it("formats average duration per task and per active execution day", () => {
+    expect(
+      countExecutionDays([
+        { started_at: "2026-07-10T12:00:00.000Z" },
+        { started_at: "2026-07-10T18:00:00.000Z" },
+        { started_at: "2026-07-11T12:00:00.000Z" },
+      ]),
+    ).toBe(2);
+    expect(formatExecutionAverageHint(36 * 3_600_000, 108, 6, "pt-BR")).toBe(
+      "20 min / tarefa (6 h / dia) (6 dias)",
+    );
+  });
+
+  it("localizes English and preserves unavailable coverage", () => {
+    expect(formatExecutionAverageHint(3_600_000, 3, 1, "en-US")).toBe(
+      "20 min / task (1 h / day) (1 day)",
+    );
+    expect(formatExecutionAverageHint(0, 0, 0, "pt-BR")).toBe("Médias de execução indisponíveis");
+  });
+});
+
+describe("token throughput summary", () => {
+  it("formats average tokens per hour and per active day in pt-BR", () => {
+    expect(formatTokenThroughputHint(1_911_000_000, 49 * 3_600_000, 7, "pt-BR")).toBe(
+      "39 M/hora (273 M/dia)",
+    );
+  });
+
+  it("localizes EN-US and preserves unavailable coverage", () => {
+    expect(formatTokenThroughputHint(1_911_000_000, 49 * 3_600_000, 7, "en-US")).toBe(
+      "39 M/hour (273 M/day)",
+    );
+    expect(formatTokenThroughputHint(0, 0, 0, "pt-BR")).toBe("Throughput indisponível");
+  });
+});
+
+describe("overviewText", () => {
+  it("provides English copy for every shared overview card and summary label", () => {
+    expect(overviewText("en-US")).toMatchObject({
+      overview: "Overview",
+      tasks: "Tasks",
+      completedTasks: "completed",
+      totalExecutionTime: "Total execution time",
+      totalRuns: "total runs",
+      cost: "Cost",
+      statusHint: "Current workflow distribution",
+      averageTime: "Average time",
+      averageTokens: "Average tokens",
+      averageCost: "Average cost",
+      topHint: "Longest accumulated durations",
+      accumulatedTime: "Accumulated time",
+      associatedRuns: "associated runs",
+      concentration: "Concentration",
+      totalMeasuredTime: "of total measured time",
+      topFiveCost: "Top 5 cost",
+      tokensUnavailable: "Tokens unavailable",
+    });
+  });
+});
+
+describe("statusColors", () => {
+  it("uses the same neutral gray for terminal non-success states", () => {
+    expect(statusColors.failed).toBe(statusColors.blocked);
+    expect(statusColors.failed).toBe(statusColors.cancelled);
+    expect(statusColors.failed).toBe("#64748b");
+  });
+});
+
+describe("averageObserved", () => {
+  it("averages only measured values", () => {
+    expect(averageObserved([10, null, 20])).toBe(15);
+  });
+
+  it("keeps a fully unavailable metric null", () => {
+    expect(averageObserved([null, null])).toBeNull();
+  });
+});
+
+describe("aggregateTaskMetrics", () => {
+  it("accumulates observed run metrics by task and ignores unlinked runs", () => {
+    const metrics = aggregateTaskMetrics(
+      [
+        { id: "TASK-1", title: "Primeira" },
+        { id: "TASK-2", title: "Segunda" },
+      ],
+      [run("TASK-1", 100, 10, 1), run("TASK-1", 200, 20, 2), run(null, 500, 50, 5)],
+    );
+
+    expect(metrics).toEqual([
+      {
+        id: "TASK-1",
+        title: "Primeira",
+        durationMs: 300,
+        tokens: 30,
+        costBrl: 3,
+        runCount: 2,
+      },
+      {
+        id: "TASK-2",
+        title: "Segunda",
+        durationMs: null,
+        tokens: null,
+        costBrl: null,
+        runCount: 0,
+      },
+    ]);
+  });
+
+  it("does not count conversation time as task execution time", () => {
+    const metrics = aggregateTaskMetrics(
+      [{ id: "TASK-1", title: "Primeira" }],
+      [
+        run("TASK-1", 100, 10, 1),
+        { ...run("TASK-1", 17 * 3_600_000, 100, 10), phase: "conversation" },
+      ],
+    );
+
+    expect(metrics).toEqual([
+      { id: "TASK-1", title: "Primeira", durationMs: 100, tokens: 110, costBrl: 11, runCount: 1 },
+    ]);
+  });
+
+  it("uses the same execution Run population as periods, including child agent work", () => {
+    const metrics = aggregateTaskMetrics(
+      [{ id: "TASK-1", title: "Primeira" }],
+      [
+        run("TASK-1", 9_360_000, 100, 10),
+        { ...run("TASK-1", 600_000, 10, 1), parent_run_id: "RUN-ROOT" },
+      ],
+    );
+
+    expect(metrics[0]).toMatchObject({
+      durationMs: 9_960_000,
+      tokens: 110,
+      costBrl: 11,
+      runCount: 2,
+    });
+  });
+});
+
+describe("aggregateMacroMetrics", () => {
+  it("aggregates only Runs linked to each macro and honors resolved costs", () => {
+    const metrics = aggregateMacroMetrics(
+      [{ id: "SPEC-1", title: "Planejamento", kind: "spec", run_ids: ["RUN-DECLARED"] }],
+      [
+        run("TASK-1", 100, 10, 1, { id: "RUN-DIRECT", specId: "SPEC-1" }),
+        run(null, 200, 20, 2, { id: "RUN-DECLARED" }),
+        run(null, 900, 90, 9, { id: "RUN-OTHER", specId: "SPEC-2" }),
+      ],
+      (runId) => (runId === "RUN-DIRECT" ? 4 : 5),
+    );
+
+    expect(metrics).toEqual([
+      {
+        id: "SPEC-1",
+        title: "Planejamento",
+        durationMs: 300,
+        tokens: 30,
+        costBrl: 9,
+        runCount: 2,
+      },
+    ]);
+  });
+});
+
+describe("macroClassificationStats", () => {
+  it("keeps structure classes mutually exclusive", () => {
+    const stats = macroClassificationStats(
+      [
+        { task_count: 0, rework_run_count: 0 },
+        { task_count: 2, rework_run_count: 0 },
+        { task_count: 3, rework_run_count: 1 },
+      ],
+      "pt-BR",
+    );
+
+    expect(stats.map(({ key, label, count }) => ({ key, label, count }))).toEqual([
+      { key: "empty", label: "Sem tarefas", count: 1 },
+      { key: "structured", label: "Com tarefas", count: 1 },
+      { key: "rework", label: "Com retrabalho", count: 1 },
+    ]);
+  });
+});
+
+describe("taskStatusDistribution", () => {
+  it("includes cancelled and failed statuses with the other task states", () => {
+    const distribution = taskStatusDistribution(
+      [
+        { status: "draft", spec_id: "SPEC-1" },
+        { status: "planned", spec_id: "SPEC-1" },
+        { status: "draft", spec_id: null },
+        {
+          status: "planned",
+          spec_id: null,
+          attempt_count: 0,
+          started_at: null,
+          execution_started: false,
+        },
+        { status: "executing", spec_id: null },
+        { status: "verifying", spec_id: null },
+        { status: "completed", spec_id: null },
+        { status: "blocked", spec_id: null },
+        { status: "cancelled", spec_id: null },
+        { status: "failed", spec_id: null },
+      ],
+      "pt-BR",
+    );
+
+    expect(distribution.map(({ key, label, count }) => ({ key, label, count }))).toEqual([
+      { key: "definition", label: "Definição (PRD + Requisitos)", count: 0 },
+      { key: "planning", label: "Planejamento (SPEC + Change)", count: 0 },
+      { key: "ready", label: "Pronto para Executar", count: 2 },
+      { key: "executing", label: "Execução", count: 1 },
+      { key: "verifying", label: "Verificação", count: 1 },
+      { key: "completed", label: "Concluído", count: 1 },
+      { key: "blocked", label: "Bloqueado", count: 1 },
+      { key: "cancelled", label: "Cancelado", count: 1 },
+      { key: "failed", label: "Falhado", count: 1 },
+    ]);
+  });
+
+  it("includes cancelled and failed statuses in the visible total", () => {
+    const visible = taskStatusDistribution(
+      [
+        { status: "draft", spec_id: "SPEC-1" },
+        { status: "planned", spec_id: "SPEC-1" },
+        {
+          status: "planned",
+          spec_id: null,
+          attempt_count: 0,
+          started_at: null,
+          execution_started: false,
+        },
+        { status: "completed", spec_id: null },
+        { status: "executing", spec_id: null },
+        { status: "blocked", spec_id: null },
+        { status: "failed", spec_id: null },
+        { status: "cancelled", spec_id: null },
+      ],
+      "pt-BR",
+    );
+
+    expect(visible.map(({ key, count }) => ({ key, count }))).toEqual([
+      { key: "definition", count: 0 },
+      { key: "planning", count: 0 },
+      { key: "ready", count: 2 },
+      { key: "executing", count: 1 },
+      { key: "verifying", count: 0 },
+      { key: "completed", count: 1 },
+      { key: "blocked", count: 1 },
+      { key: "cancelled", count: 1 },
+      { key: "failed", count: 1 },
+    ]);
+    expect(visible.reduce((total, item) => total + item.count, 0)).toBe(7);
+  });
+});
+
+describe("macroStatusDistribution", () => {
+  it("includes every macro status so the distribution totals match the macro card", () => {
+    const macros = [
+      { kind: "spec", lifecycle_status: "draft", work_status: "planning" },
+      { kind: "prd", lifecycle_status: "completed", work_status: "completed" },
+      { kind: "spec", lifecycle_status: "failed", work_status: "failed" },
+      { kind: "prd", lifecycle_status: "blocked", work_status: "blocked" },
+      { kind: "spec", lifecycle_status: "cancelled", work_status: "cancelled" },
+    ];
+    const macroCount = macros.length;
+
+    const visible = macroStatusDistribution(macros as never, [], "pt-BR");
+
+    expect(visible.map(({ key, count }) => ({ key, count }))).toEqual([
+      { key: "definition", count: 0 },
+      { key: "planning", count: 1 },
+      { key: "ready", count: 0 },
+      { key: "executing", count: 0 },
+      { key: "verifying", count: 0 },
+      { key: "completed", count: 1 },
+      { key: "blocked", count: 1 },
+      { key: "cancelled", count: 1 },
+      { key: "failed", count: 1 },
+    ]);
+    expect(visible.reduce((total, item) => total + item.count, 0)).toBe(macroCount);
+  });
+});
+
+describe("findLatestTaskCreatedAt", () => {
+  it("selects the newest task regardless of lifecycle status", () => {
+    expect(
+      findLatestTaskCreatedAt([
+        { created_at: "2026-07-16T10:00:00.000Z" },
+        { created_at: "2026-07-16T12:30:00.000Z" },
+        { created_at: "2026-07-16T11:00:00.000Z" },
+      ]),
+    ).toBe("2026-07-16T12:30:00.000Z");
+  });
+
+  it("returns null when no valid task date exists", () => {
+    expect(findLatestTaskCreatedAt([])).toBeNull();
+    expect(findLatestTaskCreatedAt([{ created_at: "invalid" }])).toBeNull();
+  });
+});
+
+describe("findLatestCreatedAt", () => {
+  it("supports nullable macro dates", () => {
+    expect(
+      findLatestCreatedAt([{ created_at: null }, { created_at: "2026-07-16T10:00:00.000Z" }]),
+    ).toBe("2026-07-16T10:00:00.000Z");
+  });
+});
+
+describe("summarizeTopEntityMetrics", () => {
+  it("summarizes the top entities against the selected entity total", () => {
+    const first = entityMetric("ONE", 100, 10, 1, 1);
+    const second = entityMetric("TWO", 300, 30, 3, 2);
+    expect(summarizeTopEntityMetrics([second], [first, second])).toEqual({
+      durationMs: 300,
+      durationShare: 0.75,
+      runCount: 2,
+      tokens: 30,
+      costBrl: 3,
+    });
+  });
+});
+
+describe("summarizeTopTaskMetrics", () => {
+  it("summarizes the selected tasks against all measured run duration", () => {
+    const runs = [run("TASK-1", 100, 10, 1), run("TASK-2", 200, 20, 2), run("TASK-3", 300, 30, 3)];
+
+    expect(
+      summarizeTopTaskMetrics(
+        [
+          { id: "TASK-1", durationMs: 100 },
+          { id: "TASK-2", durationMs: 200 },
+        ],
+        runs,
+      ),
+    ).toEqual({ durationMs: 300, durationShare: 0.5, runCount: 2, tokens: 30, costBrl: 3 });
+  });
+
+  it("keeps tokens and cost unavailable when no related run has coverage", () => {
+    expect(
+      summarizeTopTaskMetrics(
+        [{ id: "TASK-1", durationMs: 100 }],
+        [
+          {
+            ...run("TASK-1", 100, 0, 0),
+            usage: { total: { tokens: { total: null }, cost: { brl: null } } },
+          },
+        ],
+      ),
+    ).toMatchObject({ tokens: null, costBrl: null });
+  });
+
+  it("uses all observed execution duration but all related phases for top-task usage", () => {
+    const root = run("TASK-1", 2_000, 10, 1, { id: "RUN-ROOT" });
+    const child = {
+      ...run("TASK-1", 1_000, 20, 2, { id: "RUN-CHILD" }),
+      parent_run_id: "RUN-ROOT",
+    };
+    const conversation = {
+      ...run("TASK-1", 9_000, 30, 3, { id: "RUN-CONVERSATION" }),
+      phase: "conversation",
+    };
+
+    expect(
+      summarizeTopTaskMetrics([{ id: "TASK-1", durationMs: 2_000 }], [root, child, conversation]),
+    ).toEqual({
+      durationMs: 2_000,
+      durationShare: 1,
+      runCount: 3,
+      tokens: 60,
+      costBrl: 6,
+    });
+  });
+});
+
+function run(
+  taskId: string | null,
+  durationMs: number,
+  tokens: number,
+  costBrl: number,
+  links: { id?: string; specId?: string | null; prdId?: string | null } = {},
+) {
+  return {
+    id: links.id ?? `RUN-${taskId ?? "NONE"}-${durationMs}`,
+    phase: "execution",
+    task_id: taskId,
+    parent_run_id: null,
+    spec_id: links.specId ?? null,
+    prd_id: links.prdId ?? null,
+    duration_ms: durationMs,
+    usage: { total: { tokens: { total: tokens }, cost: { brl: costBrl } } },
+  };
+}
+
+function entityMetric(
+  id: string,
+  durationMs: number | null,
+  tokens: number | null,
+  costBrl: number | null,
+  runCount: number,
+) {
+  return { id, title: id, durationMs, tokens, costBrl, runCount };
+}