@zaip-ai/cli 1.0.8 → 1.3.1

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cost-group-page.test.ts

@@ -0,0 +1,176 @@
+import { DatabaseSync } from "node:sqlite";
+import { afterEach, describe, expect, it } from "vitest";
+import { type CostGroupKind, readCostGroupPage } from "./sqlite-cost-group-page.js";
+import { materializeCostGroupDailyProjection } from "./sqlite-cost-group-projection.js";
+
+const databases: DatabaseSync[] = [];
+
+afterEach(() => {
+  for (const database of databases.splice(0)) database.close();
+});
+
+function fixture() {
+  const database = new DatabaseSync(":memory:");
+  databases.push(database);
+  database.exec(`
+    CREATE TABLE cost_group_daily_projection (
+      day TEXT, group_kind TEXT, group_value TEXT,
+      invocation_count INTEGER, llm_call_count INTEGER, total_duration REAL,
+      total_input_tokens REAL, total_cached_input_tokens REAL,
+      total_output_tokens REAL, total_reasoning_tokens REAL, total_tokens REAL,
+      total_cost_usd REAL, total_cost_brl REAL
+    );
+    CREATE TABLE cost_monitor_group_daily_cache AS
+      SELECT * FROM cost_group_daily_projection;
+    CREATE TABLE cost_group_entity_projection (
+      group_kind TEXT, group_value TEXT, title TEXT, status TEXT, risk TEXT,
+      PRIMARY KEY (group_kind, group_value)
+    );
+    CREATE TABLE tasks (id TEXT PRIMARY KEY, title TEXT, status TEXT, risk TEXT);
+    CREATE TABLE specs (id TEXT PRIMARY KEY, title TEXT, status TEXT, risk TEXT);
+    CREATE TABLE prds (id TEXT PRIMARY KEY, title TEXT, status TEXT, risk TEXT);
+    CREATE TABLE executions (id TEXT PRIMARY KEY, status TEXT);
+    CREATE TABLE conversations (id TEXT PRIMARY KEY, status TEXT);
+  `);
+  return database;
+}
+
+function insertGroup(database: DatabaseSync, kind: CostGroupKind, id: string, day = "2026-08-10") {
+  const values = [day, kind, id, 2, 2, 40, 10, 2, 4, 1, 17, 1.5, 8.25];
+  for (const table of ["cost_group_daily_projection", "cost_monitor_group_daily_cache"]) {
+    database
+      .prepare(`INSERT INTO ${table} VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+      .run(...values);
+  }
+  const metadata =
+    kind === "task" || kind === "spec" || kind === "prd"
+      ? [id, `${kind} title`, "completed", "standard"]
+      : [id, "completed"];
+  database
+    .prepare(
+      kind === "task" || kind === "spec" || kind === "prd"
+        ? `INSERT OR IGNORE INTO ${kind}s VALUES (?, ?, ?, ?)`
+        : `INSERT OR IGNORE INTO ${kind}s VALUES (?, ?)`,
+    )
+    .run(...metadata);
+  database
+    .prepare(
+      `INSERT OR IGNORE INTO cost_group_entity_projection
+        VALUES (?, ?, ?, ?, ?)`,
+    )
+    .run(
+      kind,
+      id,
+      kind === "task" || kind === "spec" || kind === "prd" ? `${kind} title` : null,
+      "completed",
+      kind === "task" || kind === "spec" || kind === "prd" ? "standard" : null,
+    );
+}
+
+describe("date-only grouped Cost pages", () => {
+  it("materializes entity metadata once instead of joining dynamic entity views per page", () => {
+    const database = new DatabaseSync(":memory:");
+    databases.push(database);
+    database.exec(`
+      CREATE TABLE zaip_vw_cost_monitor_group_daily_cache (
+        day TEXT, group_kind TEXT, group_value TEXT,
+        invocation_count INTEGER, llm_call_count INTEGER, total_duration REAL,
+        total_input_tokens REAL, total_cached_input_tokens REAL,
+        total_output_tokens REAL, total_reasoning_tokens REAL, total_tokens REAL,
+        total_cost_usd REAL, total_cost_brl REAL
+      );
+      INSERT INTO zaip_vw_cost_monitor_group_daily_cache VALUES
+        ('2026-08-10', 'conversation', 'CONV-1', 1, 1, 1, 1, 0, 1, 0, 2, 0.1, 0.5),
+        ('2026-08-10', 'task', 'TASK-1', 1, 1, 1, 1, 0, 1, 0, 2, 0.1, 0.5);
+      CREATE TABLE conversation_source (id TEXT PRIMARY KEY, status TEXT);
+      INSERT INTO conversation_source VALUES ('CONV-1', 'completed');
+      CREATE VIEW zaip_vw_conversations AS SELECT * FROM conversation_source;
+      CREATE TABLE task_source (id TEXT PRIMARY KEY, title TEXT, status TEXT, risk TEXT);
+      INSERT INTO task_source VALUES ('TASK-1', 'Task title', 'executing', 'high');
+      CREATE VIEW zaip_vw_tasks AS SELECT * FROM task_source;
+      CREATE VIEW zaip_vw_specs AS SELECT * FROM task_source WHERE 0;
+      CREATE VIEW zaip_vw_prds AS SELECT * FROM task_source WHERE 0;
+      CREATE VIEW zaip_vw_executions AS SELECT id, status FROM conversation_source WHERE 0;
+    `);
+    materializeCostGroupDailyProjection(database);
+
+    expect(
+      database
+        .prepare(
+          "SELECT group_kind, group_value, title, status, risk FROM cost_group_entity_projection ORDER BY group_kind",
+        )
+        .all(),
+    ).toEqual([
+      {
+        group_kind: "conversation",
+        group_value: "CONV-1",
+        title: null,
+        status: "completed",
+        risk: null,
+      },
+      {
+        group_kind: "task",
+        group_value: "TASK-1",
+        title: "Task title",
+        status: "executing",
+        risk: "high",
+      },
+    ]);
+    expect(
+      database
+        .prepare(
+          "EXPLAIN QUERY PLAN SELECT status FROM cost_group_entity_projection WHERE group_kind='conversation' AND group_value='CONV-1'",
+        )
+        .all()
+        .map((row) => String((row as { detail: string }).detail)),
+    ).toContain(
+      "SEARCH cost_group_entity_projection USING INDEX cost_group_entity_projection_lookup (group_kind=? AND group_value=?)",
+    );
+  });
+
+  it("matches the canonical grouped source for every persisted entity kind", () => {
+    const database = fixture();
+    const views: Array<[CostGroupKind, string]> = [
+      ["execution", "cost_monitor_executions"],
+      ["task", "cost_monitor_tasks"],
+      ["conversation", "cost_monitor_conversations"],
+      ["spec", "cost_monitor_specs"],
+      ["prd", "cost_monitor_prds"],
+    ];
+    for (const [kind, view] of views) {
+      const id = `${kind.toUpperCase()}-1`;
+      insertGroup(database, kind, id);
+      const physical = readCostGroupPage(database, view, kind, {
+        from: "2026-08-01",
+        to: "2026-08-26",
+        limit: 10,
+      });
+      const canonical = readCostGroupPage(database, view, kind, {
+        from: "2026-08-01",
+        to: "2026-08-26",
+        query: id,
+        limit: 10,
+      });
+      expect(physical.total_count).toBe(1);
+      expect(physical.rows).toEqual(canonical.rows);
+      expect(physical.totals).toEqual(canonical.totals);
+    }
+  });
+
+  it("keeps complete totals and terminal export pages above 200 rows", () => {
+    const database = fixture();
+    for (let index = 0; index < 205; index += 1) {
+      insertGroup(database, "task", `TASK-${String(index).padStart(3, "0")}`);
+    }
+    const page = readCostGroupPage(database, "cost_monitor_tasks", "task", {
+      from: "2026-08-01",
+      to: "2026-08-26",
+      offset: 200,
+      limit: 200,
+    });
+    expect(page.total_count).toBe(205);
+    expect(page.rows).toHaveLength(5);
+    expect(page.has_more).toBe(false);
+    expect(page.totals).toMatchObject({ entity_count: 205, invocation_count: 410 });
+  });
+});

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cost-group-page.ts

@@ -0,0 +1,119 @@
+import type { DatabaseSync } from "node:sqlite";
+import { type DateOnlyCostPageInput, isDateOnlyCostPage } from "./sqlite-cost-agent-page.js";
+
+export type CostGroupKind = "task" | "spec" | "prd" | "execution" | "conversation";
+
+type CostGroupPageInput = DateOnlyCostPageInput & {
+  offset?: number;
+  limit?: number;
+};
+
+const entityMetadata = {
+  task: { title: "entity.title", status: "entity.status", risk: "entity.risk" },
+  spec: { title: "entity.title", status: "entity.status", risk: "entity.risk" },
+  prd: { title: "entity.title", status: "entity.status", risk: "entity.risk" },
+  execution: {
+    title: "grouped.group_value",
+    status: "entity.status",
+    risk: "NULL",
+  },
+  conversation: {
+    title: "grouped.group_value",
+    status: "entity.status",
+    risk: "NULL",
+  },
+} as const;
+
+/** Reads one exact grouped Cost page, preferring the immutable daily projection for date-only input. */
+export function readCostGroupPage(
+  database: DatabaseSync,
+  view: string,
+  groupKind: CostGroupKind,
+  input: CostGroupPageInput,
+) {
+  const metadata = entityMetadata[groupKind];
+  const clauses = ["group_kind = ?", "group_value IS NOT NULL"];
+  const values: Array<string | number> = [groupKind];
+  if (input.from) {
+    clauses.push("day >= ?");
+    values.push(input.from.slice(0, 10));
+  }
+  if (input.to) {
+    clauses.push("day <= ?");
+    values.push(input.to.slice(0, 10));
+  }
+  if (input.query) {
+    clauses.push("group_value LIKE ?");
+    values.push(`%${input.query}%`);
+  }
+  const where = clauses.join(" AND ");
+  const source = isDateOnlyCostPage(input)
+    ? "cost_group_daily_projection"
+    : "cost_monitor_group_daily_cache";
+  const total_count = Number(
+    (
+      database
+        .prepare(`SELECT COUNT(DISTINCT group_value) AS count FROM ${source} WHERE ${where}`)
+        .get(...values) as { count: number }
+    ).count,
+  );
+  // Totals precede LIMIT/OFFSET: a page is only a window into the selected population.
+  const totals = database
+    .prepare(
+      `SELECT COUNT(DISTINCT group_value) AS entity_count,
+              COALESCE(SUM(invocation_count), 0) AS invocation_count,
+              ROUND(SUM(total_duration)) AS total_duration,
+              SUM(total_tokens) AS total_tokens,
+              SUM(total_cost_usd) AS total_cost_usd,
+              SUM(total_cost_brl) AS total_cost_brl
+         FROM ${source}
+        WHERE ${where}`,
+    )
+    .get(...values) as Record<string, unknown>;
+  const limit = Math.min(200, Math.max(1, input.limit ?? 50));
+  const offset = Math.max(0, input.offset ?? 0);
+  const rows = database
+    .prepare(
+      `WITH grouped AS (
+         SELECT group_value, MIN(day) AS first_day, MAX(day) AS last_day,
+                SUM(invocation_count) AS invocation_count,
+                SUM(llm_call_count) AS llm_call_count,
+                SUM(total_duration) AS total_duration,
+                SUM(total_input_tokens) AS total_input_tokens,
+                SUM(total_cached_input_tokens) AS total_cached_input_tokens,
+                SUM(total_output_tokens) AS total_output_tokens,
+                SUM(total_reasoning_tokens) AS total_reasoning_tokens,
+                SUM(total_tokens) AS total_tokens,
+                SUM(total_cost_usd) AS total_cost_usd,
+                SUM(total_cost_brl) AS total_cost_brl
+           FROM ${source}
+          WHERE ${where}
+          GROUP BY group_value
+       )
+       SELECT grouped.group_value AS id, grouped.group_value AS key,
+              COALESCE(${metadata.title}, grouped.group_value) AS title,
+              ${metadata.status} AS status, ${metadata.risk} AS risk,
+              grouped.first_day, grouped.last_day,
+              grouped.last_day || 'T12:00:00.000Z' AS occurred_at,
+              grouped.invocation_count, grouped.llm_call_count, grouped.total_duration,
+              grouped.total_input_tokens, grouped.total_cached_input_tokens,
+              grouped.total_output_tokens, grouped.total_reasoning_tokens,
+              grouped.total_tokens, grouped.total_cost_usd, grouped.total_cost_brl
+         FROM grouped
+         LEFT JOIN cost_group_entity_projection entity
+           ON entity.group_kind = ? AND entity.group_value = grouped.group_value
+        ORDER BY grouped.total_cost_brl DESC, grouped.group_value
+        LIMIT ? OFFSET ?`,
+    )
+    .all(...values, groupKind, limit, offset) as Array<Record<string, unknown>>;
+  return {
+    data_source: "sqlite_read_model" as const,
+    view,
+    offset,
+    limit,
+    total_count,
+    has_more: offset + rows.length < total_count,
+    totals,
+    rows,
+  };
+}

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cost-group-projection.ts

@@ -0,0 +1,41 @@
+import type { DatabaseSync } from "node:sqlite";
+
+/** Freezes legacy Cost facts and their entity labels once for fast date-only pages. */
+export function materializeCostGroupDailyProjection(database: DatabaseSync): void {
+  database.exec(`
+    CREATE TABLE cost_group_daily_projection AS SELECT * FROM zaip_vw_cost_monitor_group_daily_cache;
+    CREATE INDEX cost_group_daily_projection_lookup ON cost_group_daily_projection(group_kind, day, group_value);
+
+    -- The public entity views expand canonical records and activities.  Reading
+    -- them for every grouped page was the remaining multi-second cost, most
+    -- visibly for conversations. Persist exactly the three presentation fields
+    -- the old LEFT JOIN supplied, keyed by the already-materialized population.
+    CREATE TABLE cost_group_entity_projection AS
+      SELECT 'task' AS group_kind, groups.group_value, entity.title, entity.status, entity.risk
+        FROM (SELECT DISTINCT group_value FROM cost_group_daily_projection
+              WHERE group_kind = 'task' AND group_value IS NOT NULL) groups
+        LEFT JOIN zaip_vw_tasks entity ON entity.id = groups.group_value
+      UNION ALL
+      SELECT 'spec', groups.group_value, entity.title, entity.status, entity.risk
+        FROM (SELECT DISTINCT group_value FROM cost_group_daily_projection
+              WHERE group_kind = 'spec' AND group_value IS NOT NULL) groups
+        LEFT JOIN zaip_vw_specs entity ON entity.id = groups.group_value
+      UNION ALL
+      SELECT 'prd', groups.group_value, entity.title, entity.status, entity.risk
+        FROM (SELECT DISTINCT group_value FROM cost_group_daily_projection
+              WHERE group_kind = 'prd' AND group_value IS NOT NULL) groups
+        LEFT JOIN zaip_vw_prds entity ON entity.id = groups.group_value
+      UNION ALL
+      SELECT 'execution', groups.group_value, NULL, entity.status, NULL
+        FROM (SELECT DISTINCT group_value FROM cost_group_daily_projection
+              WHERE group_kind = 'execution' AND group_value IS NOT NULL) groups
+        LEFT JOIN zaip_vw_executions entity ON entity.id = groups.group_value
+      UNION ALL
+      SELECT 'conversation', groups.group_value, NULL, entity.status, NULL
+        FROM (SELECT DISTINCT group_value FROM cost_group_daily_projection
+              WHERE group_kind = 'conversation' AND group_value IS NOT NULL) groups
+        LEFT JOIN zaip_vw_conversations entity ON entity.id = groups.group_value;
+    CREATE UNIQUE INDEX cost_group_entity_projection_lookup
+      ON cost_group_entity_projection(group_kind, group_value);
+  `);
+}

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cost-invocation-page.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { filterCostInvocationProjection } from "./sqlite-cost-invocation-page.js";
+
+describe("cost invocation projection page", () => {
+  it("uses the Sao Paulo source day for the fast date-only page", () => {
+    const rows = [
+      { agent_invocation_id: "before", source_started_at: "2026-08-01T02:30:00.000Z" },
+      { agent_invocation_id: "inside", source_started_at: "2026-08-01T03:30:00.000Z" },
+    ];
+    expect(
+      filterCostInvocationProjection(rows, { from: "2026-08-01", to: "2026-08-01" }).map(
+        (row) => row.agent_invocation_id,
+      ),
+    ).toEqual(["inside"]);
+  });
+});

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cost-invocation-page.ts

@@ -0,0 +1,29 @@
+type CostInvocationDateFilter = { from?: string | null; to?: string | null };
+
+function costDay(value: string | null | undefined): string | null {
+  if (!value) return null;
+  if (/^\d{4}-\d{2}-\d{2}$/.test(value)) return value;
+  const date = new Date(value);
+  if (Number.isNaN(date.valueOf())) return null;
+  const values = new Intl.DateTimeFormat("en-CA", {
+    timeZone: "America/Sao_Paulo",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  }).formatToParts(date);
+  return `${values.find((part) => part.type === "year")?.value}-${values.find((part) => part.type === "month")?.value}-${values.find((part) => part.type === "day")?.value}`;
+}
+
+/** Filters the rebuild-time invocation projection without expanding its costly view. */
+export function filterCostInvocationProjection(
+  rows: Array<Record<string, unknown>>,
+  input: CostInvocationDateFilter,
+) {
+  const from = costDay(input.from);
+  const to = costDay(input.to);
+  return rows.filter((row) => {
+    const timestamp = row.source_started_at ?? row.source_occurred_at ?? row.occurred_at;
+    const day = typeof timestamp === "string" ? costDay(timestamp) : null;
+    return day !== null && (from === null || day >= from) && (to === null || day <= to);
+  });
+}