@zaip-ai/cli 1.0.4 → 1.0.7

package/templates/.agents/dashboard/modules/operations/src/react/OperationsOverview.helpers.tsx

@@ -0,0 +1,412 @@
+import { formatCompactNumber } from "@zaip-ai/dashboard-ui";
+import type { MacroProjection, OperationsProjection } from "../contracts.js";
+import {
+  executionMetricRuns,
+  metricRuns,
+  observedDuration,
+  sumObserved,
+} from "./execution-metrics.js";
+import { formatDurationInHours, formatRoundedDuration } from "./format-rounded-duration.js";
+import type { OperationsLocale } from "./status-labels.js";
+import type { WorkStage } from "./work-board-model.js";
+
+export const statusColors: Record<WorkStage, string> = {
+  definition: "#a78bfa",
+  planning: "#3f6fbd",
+  ready: "#38bdf8",
+  executing: "#fbbf24",
+  verifying: "#f87171",
+  completed: "#34d399",
+  blocked: "#64748b",
+  cancelled: "#64748b",
+  failed: "#64748b",
+};
+const _terminalTaskStatuses = new Set<WorkStage>(["blocked", "cancelled", "failed"]);
+export const riskColors = { lite: "#60a5fa", standard: "#fbbf24", critical: "#f87171" } as const;
+const macroClassificationColors = {
+  empty: "#60a5fa",
+  structured: "#fbbf24",
+  rework: "#f87171",
+} as const;
+
+export function averageObserved(values: readonly (number | null)[]): number | null {
+  const observed = values.filter((value): value is number => value !== null);
+  return observed.length === 0
+    ? null
+    : observed.reduce((total, value) => total + value, 0) / observed.length;
+}
+
+export function findLatestTaskCreatedAt(
+  tasks: readonly Pick<OperationsProjection["tasks"][number], "created_at">[],
+): string | null {
+  return findLatestCreatedAt(tasks);
+}
+
+export function findLatestCreatedAt(
+  entities: readonly { created_at: string | null }[],
+): string | null {
+  let latest: { value: string; timestamp: number } | null = null;
+  for (const entity of entities) {
+    if (entity.created_at === null) continue;
+    const timestamp = Date.parse(entity.created_at);
+    if (Number.isNaN(timestamp)) continue;
+    if (latest === null || timestamp > latest.timestamp) {
+      latest = { value: entity.created_at, timestamp };
+    }
+  }
+  return latest?.value ?? null;
+}
+
+export function aggregateTaskMetrics(
+  tasks: readonly Pick<OperationsProjection["tasks"][number], "id" | "title" | "telemetry">[],
+  runs: readonly {
+    id: string;
+    phase: string;
+    task_id: string | null;
+    parent_run_id: string | null;
+    duration_ms: number | null;
+    usage: {
+      total: {
+        tokens: { total: number | null };
+        cost: { brl: number | null };
+      };
+    };
+  }[],
+  resolveRunCostBrl?: ((runId: string) => number | null) | undefined,
+) {
+  const metrics = new Map(
+    tasks.map((task) => [
+      task.id,
+      {
+        id: task.id,
+        title: task.title,
+        durationMs: task.telemetry?.duration_ms ?? null,
+        tokens: task.telemetry?.tokens ?? null,
+        costBrl: task.telemetry?.cost_brl ?? null,
+        runCount: task.telemetry === null || task.telemetry === undefined ? 0 : 1,
+      },
+    ]),
+  );
+
+  if (runs.length === 0) return [...metrics.values()];
+  for (const metric of metrics.values()) {
+    metric.durationMs = null;
+    metric.tokens = null;
+    metric.costBrl = null;
+    metric.runCount = 0;
+  }
+  for (const run of executionMetricRuns(runs)) {
+    if (run.task_id === null) continue;
+    const task = metrics.get(run.task_id);
+    if (task === undefined) continue;
+    task.runCount += 1;
+    const durationMs = observedDuration(run.duration_ms);
+    if (durationMs !== null) task.durationMs = (task.durationMs ?? 0) + durationMs;
+  }
+  for (const run of metricRuns(runs)) {
+    if (run.task_id === null) continue;
+    const task = metrics.get(run.task_id);
+    if (task === undefined) continue;
+    if (run.usage.total.tokens.total !== null)
+      task.tokens = (task.tokens ?? 0) + run.usage.total.tokens.total;
+    const costBrl = resolveRunCostBrl ? resolveRunCostBrl(run.id) : run.usage.total.cost.brl;
+    if (costBrl !== null) task.costBrl = (task.costBrl ?? 0) + costBrl;
+  }
+
+  return [...metrics.values()];
+}
+
+export function aggregateMacroMetrics(
+  macros: readonly (Pick<MacroProjection, "id" | "title" | "kind" | "run_ids"> &
+    Partial<Pick<MacroProjection, "duration_ms" | "usage" | "run_count">>)[],
+  runs: readonly {
+    id: string;
+    phase: string;
+    spec_id: string | null;
+    prd_id: string | null;
+    duration_ms: number | null;
+    usage: {
+      total: {
+        tokens: { total: number | null };
+        cost: { brl: number | null };
+      };
+    };
+  }[],
+  resolveRunCostBrl?: ((runId: string) => number | null) | undefined,
+) {
+  return macros.map((macro) => {
+    if (runs.length === 0) {
+      return {
+        id: macro.id,
+        title: macro.title,
+        durationMs: macro.duration_ms ?? null,
+        tokens: macro.usage?.total.tokens.total ?? null,
+        costBrl: macro.usage?.total.cost.brl ?? null,
+        runCount: macro.run_count ?? 0,
+      };
+    }
+    const declaredRunIds = new Set(macro.run_ids);
+    const isRelated = (run: (typeof runs)[number]) =>
+      declaredRunIds.has(run.id) ||
+      (macro.kind === "spec" ? run.spec_id === macro.id : run.prd_id === macro.id);
+    const relatedDurationRuns = executionMetricRuns(runs).filter(isRelated);
+    const relatedUsageRuns = metricRuns(runs).filter(isRelated);
+    return {
+      id: macro.id,
+      title: macro.title,
+      durationMs: sumObserved(relatedDurationRuns.map((run) => run.duration_ms)),
+      tokens: sumObserved(relatedUsageRuns.map((run) => run.usage.total.tokens.total)),
+      costBrl: sumObserved(
+        relatedUsageRuns.map((run) =>
+          resolveRunCostBrl ? resolveRunCostBrl(run.id) : run.usage.total.cost.brl,
+        ),
+      ),
+      runCount: relatedUsageRuns.length,
+    };
+  });
+}
+
+export function macroClassificationStats(
+  macros: readonly Pick<MacroProjection, "task_count" | "rework_run_count">[],
+  locale: OperationsLocale,
+) {
+  const isPortuguese = locale === "pt-BR";
+  return [
+    {
+      key: "empty",
+      label: isPortuguese ? "Sem tarefas" : "Without tasks",
+      color: macroClassificationColors.empty,
+      count: macros.filter((macro) => macro.task_count === 0).length,
+    },
+    {
+      key: "structured",
+      label: isPortuguese ? "Com tarefas" : "With tasks",
+      color: macroClassificationColors.structured,
+      count: macros.filter((macro) => macro.task_count > 0 && macro.rework_run_count === 0).length,
+    },
+    {
+      key: "rework",
+      label: isPortuguese ? "Com retrabalho" : "With rework",
+      color: macroClassificationColors.rework,
+      count: macros.filter((macro) => macro.rework_run_count > 0).length,
+    },
+  ];
+}
+
+export function summarizeTopEntityMetrics(
+  topEntities: readonly EntityMetric[],
+  allEntities: readonly EntityMetric[],
+) {
+  const durationMs = topEntities.reduce((sum, entity) => sum + (entity.durationMs ?? 0), 0);
+  const totalDurationMs = allEntities.reduce((sum, entity) => sum + (entity.durationMs ?? 0), 0);
+  return {
+    durationMs,
+    durationShare: totalDurationMs === 0 ? 0 : durationMs / totalDurationMs,
+    runCount: topEntities.reduce((sum, entity) => sum + entity.runCount, 0),
+    tokens: sumObserved(topEntities.map((entity) => entity.tokens)),
+    costBrl: sumObserved(topEntities.map((entity) => entity.costBrl)),
+  };
+}
+
+interface EntityMetric {
+  id: string;
+  title: string;
+  durationMs: number | null;
+  tokens: number | null;
+  costBrl: number | null;
+  runCount: number;
+}
+
+export function summarizeTopTaskMetrics(
+  topTasks: readonly { id: string; durationMs: number | null }[],
+  runs: readonly {
+    id: string;
+    phase: string;
+    task_id: string | null;
+    duration_ms: number | null;
+    usage: { total: { tokens: { total: number | null }; cost: { brl: number | null } } };
+  }[],
+  resolveRunCostBrl?: ((runId: string) => number | null) | undefined,
+) {
+  const topTaskIds = new Set(topTasks.map((task) => task.id));
+  const durationPopulation = executionMetricRuns(runs);
+  const usagePopulation = metricRuns(runs);
+  const relatedUsageRuns = usagePopulation.filter(
+    (run) => run.task_id !== null && topTaskIds.has(run.task_id),
+  );
+  const durationMs = topTasks.reduce((sum, task) => sum + (task.durationMs ?? 0), 0);
+  const totalDurationMs = durationPopulation.reduce(
+    (sum, run) => sum + (observedDuration(run.duration_ms) ?? 0),
+    0,
+  );
+
+  return {
+    durationMs,
+    durationShare: totalDurationMs === 0 ? 0 : durationMs / totalDurationMs,
+    runCount: relatedUsageRuns.length,
+    tokens: sumObserved(relatedUsageRuns.map((run) => run.usage.total.tokens.total)),
+    costBrl: sumObserved(
+      relatedUsageRuns.map((run) =>
+        resolveRunCostBrl ? resolveRunCostBrl(run.id) : run.usage.total.cost.brl,
+      ),
+    ),
+  };
+}
+
+export function Kpi({
+  label,
+  value,
+  hint,
+  featured = false,
+  onSelect,
+}: {
+  label: string;
+  value: string;
+  hint: string;
+  featured?: boolean;
+  onSelect?: (() => void) | undefined;
+}) {
+  const content = (
+    <>
+      <span>{label}</span>
+      <strong>{value}</strong>
+      <small>{hint}</small>
+    </>
+  );
+  if (onSelect !== undefined) {
+    return (
+      <button
+        aria-pressed={featured}
+        aria-label={`${label}: ${value}. ${hint}`}
+        className={`operations-kpi is-selectable${featured ? " is-featured" : ""}`}
+        onClick={onSelect}
+        type="button"
+      >
+        {content}
+      </button>
+    );
+  }
+  return (
+    <article
+      aria-label={`${label}: ${value}. ${hint}`}
+      className={`operations-kpi${featured ? " is-featured" : ""}`}
+    >
+      {content}
+    </article>
+  );
+}
+
+export function overviewText(locale: OperationsLocale) {
+  const isPortuguese = locale === "pt-BR";
+  return {
+    overview: isPortuguese ? "Visão geral" : "Overview",
+    tasks: isPortuguese ? "Tarefas" : "Tasks",
+    completedTasks: isPortuguese ? "concluídas" : "completed",
+    completedSpecs: isPortuguese ? "concluídas" : "completed",
+    completedPrds: isPortuguese ? "concluídos" : "completed",
+    totalExecutionTime: isPortuguese ? "Tempo total de execução" : "Total execution time",
+    totalRuns: isPortuguese ? "runs totais" : "total runs",
+    cost: isPortuguese ? "Custo" : "Cost",
+    showTerminal: isPortuguese
+      ? "Mostrar canceladas, bloqueadas e falhadas"
+      : "Show cancelled, blocked, and failed",
+    hideTerminal: isPortuguese
+      ? "Esconder canceladas, bloqueadas e falhadas"
+      : "Hide cancelled, blocked, and failed",
+    statusHint: isPortuguese ? "Distribuição atual do fluxo" : "Current workflow distribution",
+    averageTime: isPortuguese ? "Tempo médio" : "Average time",
+    averageTokens: isPortuguese ? "Tokens médios" : "Average tokens",
+    averageCost: isPortuguese ? "Custo médio" : "Average cost",
+    topHint: isPortuguese ? "Maiores durações acumuladas" : "Longest accumulated durations",
+    accumulatedTime: isPortuguese ? "Tempo acumulado" : "Accumulated time",
+    associatedRuns: isPortuguese ? "runs associadas" : "associated runs",
+    concentration: isPortuguese ? "Concentração" : "Concentration",
+    totalMeasuredTime: isPortuguese ? "do tempo total medido" : "of total measured time",
+    topFiveCost: isPortuguese ? "Custo do Top 5" : "Top 5 cost",
+    tokensUnavailable: isPortuguese ? "Tokens indisponíveis" : "Tokens unavailable",
+  } as const;
+}
+
+export function countExecutionDays(runs: readonly { started_at: string }[]): number {
+  const days = new Set<string>();
+  for (const run of runs) {
+    const date = new Date(run.started_at);
+    if (Number.isNaN(date.getTime())) continue;
+    days.add(`${date.getFullYear()}-${date.getMonth()}-${date.getDate()}`);
+  }
+  return days.size;
+}
+
+export function formatExecutionAverageHint(
+  totalDurationMs: number,
+  totalTasks: number,
+  totalDays: number,
+  locale: OperationsLocale,
+): string {
+  if (totalDurationMs <= 0 || totalTasks <= 0 || totalDays <= 0) {
+    return locale === "pt-BR"
+      ? "Médias de execução indisponíveis"
+      : "Execution averages unavailable";
+  }
+  const averagePerTask = formatRoundedDuration(totalDurationMs / totalTasks, locale);
+  const averagePerDay = formatDurationInHours(totalDurationMs / totalDays);
+  const totalDaysLabel =
+    locale === "pt-BR" ? `${totalDays} dias` : `${totalDays} ${totalDays === 1 ? "day" : "days"}`;
+  return locale === "pt-BR"
+    ? `${averagePerTask} / tarefa (${averagePerDay} / dia) (${totalDaysLabel})`
+    : `${averagePerTask} / task (${averagePerDay} / day) (${totalDaysLabel})`;
+}
+
+export function formatTokenThroughputHint(
+  totalTokens: number,
+  totalDurationMs: number,
+  totalDays: number,
+  locale: OperationsLocale,
+): string {
+  if (totalDurationMs <= 0 || totalDays <= 0) {
+    return locale === "pt-BR" ? "Throughput indisponível" : "Throughput unavailable";
+  }
+  const tokensPerHour = (totalTokens * 3_600_000) / totalDurationMs;
+  const averageHoursPerDay = totalDurationMs / 3_600_000 / totalDays;
+  const tokensPerDay = tokensPerHour * averageHoursPerDay;
+  return `${formatCompactNumber(tokensPerHour, locale)}${locale === "pt-BR" ? "/hora" : "/hour"} (${formatCompactNumber(tokensPerDay, locale)}${locale === "pt-BR" ? "/dia" : "/day"})`;
+}
+
+export function overviewCopy(view: "tasks" | "specs" | "prds", locale: OperationsLocale) {
+  const isPortuguese = locale === "pt-BR";
+  if (view === "tasks") {
+    return {
+      statusTitle: isPortuguese ? "Status das tarefas" : "Task status",
+      classificationTitle: isPortuguese ? "Classificação de Tarefa" : "Task classification",
+      classificationHint: isPortuguese ? "Mix por criticidade" : "Criticality mix",
+      averageTitle: isPortuguese ? "Média por tarefa" : "Average per task",
+      averageHint: isPortuguese ? "Runs agregadas" : "Runs aggregated per task",
+      latestLabel: isPortuguese ? "Última tarefa criada" : "Latest task created",
+      topTitle: isPortuguese ? "Top 5 tarefas" : "Top 5 tasks",
+      shortPlural: "tasks",
+      emptyTop: isPortuguese
+        ? "Nenhuma tarefa com duração registrada."
+        : "No task has a recorded duration.",
+    };
+  }
+  const isSpec = view === "specs";
+  const singular = isSpec ? "SPEC" : "PRD";
+  const plural = isSpec ? "SPECs" : "PRDs";
+  return {
+    statusTitle: isPortuguese ? `Status das ${plural}` : `${singular} status`,
+    classificationTitle: isPortuguese
+      ? `Classificação de ${singular}`
+      : `${singular} classification`,
+    classificationHint: isPortuguese ? "Estrutura da entrega" : "Delivery structure",
+    averageTitle: isPortuguese ? `Média por ${singular}` : `Average per ${singular}`,
+    averageHint: isPortuguese
+      ? `Runs agregadas por ${singular}`
+      : `Runs aggregated per ${singular}`,
+    latestLabel: isPortuguese ? `Última ${singular} criada` : `Latest ${singular} created`,
+    topTitle: `Top 5 ${plural}`,
+    shortPlural: plural,
+    emptyTop: isPortuguese
+      ? `Nenhuma ${singular} com duração registrada.`
+      : `No ${singular} has a recorded duration.`,
+  };
+}