@zaip-ai/cli 1.0.7 → 1.3.0

package/templates/.agents/dashboard/packages/local-runtime/src/server-daily-read-models.ts

@@ -0,0 +1,194 @@
+import type {
+  CompactLifecycleDetail,
+  DailyLifecycleReadModelsSnapshot,
+} from "@zaip-ai/lifecycle-manifests";
+import { saoPauloPeriodKey } from "@zaip-ai/lifecycle-manifests";
+
+export type DailyReadModelKind =
+  | "overview"
+  | "tasks"
+  | "specs"
+  | "prds"
+  | "executions"
+  | "conversations";
+
+export function pageDailyReadModel(
+  snapshot: DailyLifecycleReadModelsSnapshot,
+  kind: DailyReadModelKind,
+  range: { from: string | null; to: string | null },
+  filters: { query: string; status: string; risk: string },
+  offset: number,
+  limit: number,
+  cursor: string | null = null,
+) {
+  const allDays = Object.entries(snapshot.days).sort(([left], [right]) =>
+    right.localeCompare(left),
+  );
+  const fromDay = range.from === null ? null : requestedDay(range.from);
+  const toDay = range.to === null ? null : requestedDay(range.to);
+  const days = allDays.filter(
+    ([day]) => (fromDay === null || day >= fromDay) && (toDay === null || day <= toDay),
+  );
+  const source =
+    kind === "overview"
+      ? days.map(([day, model]) => ({ day, ...model.overview }))
+      : includeActiveWindowRows(
+          kind,
+          aggregateDetails(days.flatMap(([, model]) => model[kind])),
+          aggregateDetails(allDays.flatMap(([, model]) => model[kind])),
+          range,
+        );
+  const rows = source.filter((row) => matches(row, filters));
+  const cursorKey = parseCursor(cursor);
+  const eligible =
+    cursorKey === null
+      ? rows
+      : rows.filter((row) => `${rowKey(row)}\u0000${rowId(row)}` < cursorKey);
+  const pageOffset = cursorKey === null ? offset : 0;
+  const page = eligible.slice(pageOffset, pageOffset + limit);
+  const last = page.at(-1);
+  return {
+    data_source: "lifecycle_daily_read_models" as const,
+    snapshot_id: snapshot.updated_at,
+    source_latest_at: snapshot.source_latest_at,
+    kind,
+    offset: pageOffset,
+    limit,
+    total: rows.length,
+    has_more: pageOffset + limit < eligible.length,
+    next_cursor:
+      last === undefined || pageOffset + limit >= eligible.length
+        ? null
+        : encodeCursor(rowKey(last), rowId(last)),
+    rows: page,
+  };
+}
+
+function requestedDay(value: string): string | null {
+  // Date-only query parameters already name a civil Sao Paulo day. Parsing
+  // them as UTC first would move midnight into the prior local day.
+  if (/^\d{4}-\d{2}-\d{2}$/.test(value)) return value;
+  return saoPauloPeriodKey(value, "day");
+}
+
+function includeActiveWindowRows(
+  kind: Exclude<DailyReadModelKind, "overview">,
+  periodRows: readonly CompactLifecycleDetail[],
+  allRows: readonly CompactLifecycleDetail[],
+  range: { from: string | null; to: string | null },
+): CompactLifecycleDetail[] {
+  if (kind !== "tasks" && kind !== "specs" && kind !== "prds") return [...periodRows];
+  const terminal = new Set([
+    "completed",
+    "delivered",
+    "failed",
+    "cancelled",
+    "superseded",
+    "rolled_back",
+  ]);
+  const currentById = new Map(allRows.map((row) => [row.id, row]));
+  const eligiblePeriodRows = periodRows.filter((row) => {
+    const current = currentById.get(row.id) ?? row;
+    if (current.status === null || !terminal.has(current.status)) return true;
+    // A terminal entity can still have a Run fact inside the selected period
+    // (for example, a completed Task created in December with January
+    // execution). The daily read model already selected that activity fact;
+    // do not discard it solely because the entity's terminal boundary is old.
+    if (row.run_count > 0) return true;
+    const boundary = current.window_at ?? current.occurred_at;
+    return (
+      (range.from === null || boundary >= range.from) && (range.to === null || boundary <= range.to)
+    );
+  });
+  const present = new Set(eligiblePeriodRows.map((row) => row.id));
+  const zero = () => ({ known_sum: 0, unknown: 0, complete: true, coverage_ratio: 1 });
+  return [
+    ...eligiblePeriodRows,
+    ...allRows
+      .filter((row) => !present.has(row.id) && (row.status === null || !terminal.has(row.status)))
+      .map((row) => ({
+        ...row,
+        run_count: 0,
+        cost_currency: null,
+        metrics: { duration: zero(), total_tokens: zero(), cost: zero() },
+      })),
+  ].sort(
+    (left, right) =>
+      right.occurred_at.localeCompare(left.occurred_at) || left.id.localeCompare(right.id),
+  );
+}
+
+function aggregateDetails(rows: readonly CompactLifecycleDetail[]): CompactLifecycleDetail[] {
+  const grouped = new Map<string, CompactLifecycleDetail>();
+  for (const row of rows) {
+    const current = grouped.get(row.id);
+    if (current === undefined) {
+      grouped.set(row.id, structuredClone(row));
+      continue;
+    }
+    const currentRunCount = current.run_count;
+    if (row.run_count > 0) {
+      const sourceElapsed = row.lifecycle_elapsed_ms ?? null;
+      if (currentRunCount === 0) current.lifecycle_elapsed_ms = sourceElapsed;
+      else {
+        const currentElapsed = current.lifecycle_elapsed_ms ?? null;
+        current.lifecycle_elapsed_ms =
+          currentElapsed === null || sourceElapsed === null ? null : currentElapsed + sourceElapsed;
+      }
+    }
+    current.run_count += row.run_count;
+    for (const key of ["duration", "total_tokens", "cost"] as const) {
+      const target = current.metrics[key];
+      const source = row.metrics[key];
+      target.known_sum += source.known_sum;
+      target.unknown += source.unknown;
+      target.complete = target.unknown === 0;
+      const total = current.run_count;
+      target.coverage_ratio =
+        total === 0 ? 1 : Math.max(0, Math.min(1, (total - target.unknown) / total));
+    }
+  }
+  return [...grouped.values()].sort(
+    (left, right) =>
+      right.occurred_at.localeCompare(left.occurred_at) || left.id.localeCompare(right.id),
+  );
+}
+
+function rowKey(row: object): string {
+  const value = row as Record<string, unknown>;
+  return typeof value.occurred_at === "string"
+    ? value.occurred_at
+    : typeof value.day === "string"
+      ? value.day
+      : "";
+}
+function rowId(row: object): string {
+  const value = row as Record<string, unknown>;
+  return typeof value.id === "string" ? value.id : typeof value.day === "string" ? value.day : "";
+}
+function encodeCursor(key: string, id: string): string {
+  return encodeURIComponent(JSON.stringify([key, id]));
+}
+function parseCursor(cursor: string | null): string | null {
+  if (cursor === null) return null;
+  try {
+    const value = JSON.parse(decodeURIComponent(cursor));
+    return Array.isArray(value) && typeof value[0] === "string" && typeof value[1] === "string"
+      ? `${value[0]}\u0000${value[1]}`
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function matches(
+  value: CompactLifecycleDetail | Record<string, unknown>,
+  filters: { query: string; status: string; risk: string },
+): boolean {
+  if (filters.status && value.status !== filters.status) return false;
+  if (filters.risk && value.risk !== filters.risk) return false;
+  if (!filters.query) return true;
+  return Object.values(value).some(
+    (field) => typeof field === "string" && field.toLocaleLowerCase().includes(filters.query),
+  );
+}

package/templates/.agents/dashboard/packages/local-runtime/src/server-operations-pages.test.ts

@@ -0,0 +1,163 @@
+import { describe, expect, it } from "vitest";
+import {
+  executionEntityPageRows,
+  executionLifecycleElapsedMs,
+  lifecycleElapsedMs,
+} from "./server-operations-pages.js";
+
+describe("executionEntityPageRows", () => {
+  it("uses an observed Execution duration only when no root Run is known", () => {
+    const rows = executionEntityPageRows(
+      [
+        {
+          id: "EXEC-1",
+          status: "completed",
+          updated_at: "2026-08-07T12:00:00.000Z",
+          data: {
+            kind: "interaction",
+            created_at: "2026-08-07T12:00:00.000Z",
+            duration_ms: 120_000,
+            duration_provenance: "observed",
+            origin: { type: "interaction", conversation_id: "CONV-1" },
+          },
+        },
+      ],
+      [],
+      "conversations",
+      null,
+      null,
+    );
+    expect(rows).toMatchObject([
+      { id: "CONV-1", execution_id: "EXEC-1", conversation_id: "CONV-1", duration_ms: 120_000 },
+    ]);
+  });
+
+  it("does not promote a child-only Run to root duration while retaining independent usage", () => {
+    const rows = executionEntityPageRows(
+      [
+        {
+          id: "EXEC-2",
+          status: "completed",
+          updated_at: "2026-08-07T12:00:00.000Z",
+          data: {
+            kind: "interaction",
+            created_at: "2026-08-07T12:00:00.000Z",
+            origin: { type: "interaction", conversation_id: "CONV-2" },
+          },
+        },
+      ],
+      [
+        {
+          id: "SUB-1",
+          started_at: "2026-08-07T12:00:00.000Z",
+          finished_at: null,
+          task_id: null,
+          execution_id: "EXEC-2",
+          conversation_id: "CONV-2",
+          run_kind: "subrun",
+          phase: "execution",
+          parent_run_id: "ROOT-1",
+          status: "completed",
+          duration_ms: 90_000,
+          total_tokens: 10,
+          cost: 2,
+          currency: "BRL",
+          events: null,
+        },
+      ],
+      "conversations",
+      null,
+      null,
+    );
+    expect(rows).toMatchObject([
+      { id: "CONV-2", execution_id: "EXEC-2", duration_ms: null, total_tokens: 10, cost: 2 },
+    ]);
+  });
+
+  it("keeps observed duration unavailable when a root Run has no source duration", () => {
+    const rows = executionEntityPageRows(
+      [
+        {
+          id: "EXEC-3",
+          status: "completed",
+          updated_at: "2026-08-07T12:00:00.000Z",
+          data: {
+            kind: "delivery",
+            created_at: "2026-08-07T12:00:00.000Z",
+            finished_at: "2026-08-07T12:02:00.000Z",
+            duration_ms: 120_000,
+            duration_provenance: "observed",
+            origin: { type: "task", task_id: "TASK-3" },
+          },
+        },
+      ],
+      [
+        {
+          id: "ROOT-3",
+          started_at: "2026-08-07T12:00:00.000Z",
+          finished_at: "2026-08-07T12:02:00.000Z",
+          task_id: "TASK-3",
+          execution_id: "EXEC-3",
+          conversation_id: null,
+          run_kind: "run",
+          phase: "execution",
+          parent_run_id: null,
+          status: "completed",
+          duration_ms: null,
+          total_tokens: null,
+          cost: null,
+          currency: null,
+          events: null,
+        },
+      ],
+      "executions",
+      null,
+      null,
+    );
+    expect(rows).toMatchObject([
+      { id: "EXEC-3", duration_ms: null, lifecycle_elapsed_ms: 120_000 },
+    ]);
+  });
+});
+
+describe("lifecycleElapsedMs", () => {
+  it("is terminal-only and never substitutes source-observed duration", () => {
+    expect(
+      lifecycleElapsedMs("completed", "2026-08-07T12:00:00.000Z", "2026-08-07T12:02:00.000Z"),
+    ).toBe(120_000);
+    expect(
+      lifecycleElapsedMs("running", "2026-08-07T12:00:00.000Z", "2026-08-07T12:02:00.000Z"),
+    ).toBeNull();
+    expect(lifecycleElapsedMs("completed", "invalid", "2026-08-07T12:02:00.000Z")).toBeNull();
+    expect(
+      lifecycleElapsedMs("completed", "2026-08-07T12:02:00.000Z", "2026-08-07T12:00:00.000Z"),
+    ).toBeNull();
+  });
+});
+
+describe("executionLifecycleElapsedMs", () => {
+  it("uses the min/max interval of deduplicated terminal related Runs", () => {
+    const rows = [
+      {
+        id: "RUN-1",
+        started_at: "2026-08-07T12:00:00.000Z",
+        finished_at: "2026-08-07T12:02:00.000Z",
+        status: "completed",
+      },
+      {
+        id: "RUN-1",
+        started_at: "2026-08-07T12:00:00.000Z",
+        finished_at: "2026-08-07T12:02:00.000Z",
+        status: "completed",
+      },
+      {
+        id: "SUB-2",
+        started_at: "2026-08-07T12:01:00.000Z",
+        finished_at: "2026-08-07T12:05:00.000Z",
+        status: "failed",
+      },
+    ] as unknown as Parameters<typeof executionLifecycleElapsedMs>[0];
+    expect(executionLifecycleElapsedMs(rows)).toBe(300_000);
+    expect(executionLifecycleElapsedMs([{ ...rows[0]!, status: "running" }])).toBeNull();
+  });
+});