@zaip-ai/cli 2.2.0 → 2.6.0

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-query-filtered-dimension.ts

@@ -0,0 +1,292 @@
+import type { SqliteQueryContext, SqliteViewInput } from "./sqlite-query-context.js";
+import { costMonitorFilterDay } from "./sqlite-read-model-canonical.js";
+import type { SqliteViewName } from "./sqlite-read-model-types.js";
+export function readFilteredDimension(
+  context: SqliteQueryContext,
+  view: SqliteViewName,
+  input: SqliteViewInput,
+  filteredCostGroup: "day" | "month" | "year" | "agent" | "model" | "provider",
+) {
+  const temporalCostGroup =
+    filteredCostGroup === "day" || filteredCostGroup === "month" || filteredCostGroup === "year";
+
+  if (temporalCostGroup && input.workType) {
+    // No canonical work_type exists at invocation grain, including for
+    // duration/Run completion backfills. Do not emit unrelated buckets.
+    return {
+      data_source: "sqlite_read_model" as const,
+      view,
+      offset: Math.max(0, input.offset ?? 0),
+      limit: Math.min(200, Math.max(1, input.limit ?? 50)),
+      total_count: 0,
+      has_more: false,
+      rows: [],
+    };
+  }
+  const groupExpression =
+    filteredCostGroup === "day"
+      ? "date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours')"
+      : filteredCostGroup === "month"
+        ? "substr(date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours'), 1, 7)"
+        : filteredCostGroup === "year"
+          ? "substr(date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours'), 1, 4)"
+          : "i.provider_group";
+  const clauses = [
+    `${groupExpression} IS NOT NULL`,
+    "(i.total_tokens IS NOT NULL OR i.cost_usd IS NOT NULL OR i.cost_brl IS NOT NULL)",
+  ];
+  const values: Array<string | number> = [];
+  if (input.from) {
+    clauses.push(
+      "date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours') >= ?",
+    );
+    values.push(costMonitorFilterDay(input.from)!);
+  }
+  if (input.to) {
+    clauses.push(
+      "date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours') <= ?",
+    );
+    values.push(costMonitorFilterDay(input.to)!);
+  }
+  const usageSegmentClauses: string[] = [];
+  if (input.provider) {
+    if (input.provider === "unavailable") {
+      clauses.push(
+        "NOT EXISTS (SELECT 1 FROM invocation_usage known_provider WHERE known_provider.agent_invocation_id=i.agent_invocation_id AND known_provider.provider IS NOT NULL AND known_provider.provider <> 'unavailable')",
+      );
+    } else {
+      usageSegmentClauses.push("f.provider=?");
+      values.push(input.provider);
+    }
+  }
+  if (input.model) {
+    if (input.model === "unavailable") {
+      clauses.push(
+        "NOT EXISTS (SELECT 1 FROM invocation_usage known_model WHERE known_model.agent_invocation_id=i.agent_invocation_id AND known_model.model IS NOT NULL AND known_model.model <> 'unavailable')",
+      );
+    } else {
+      usageSegmentClauses.push("f.model=?");
+      values.push(input.model);
+    }
+  }
+  if (usageSegmentClauses.length > 0)
+    clauses.push(
+      `EXISTS (SELECT 1 FROM invocation_usage f WHERE f.agent_invocation_id=i.agent_invocation_id AND ${usageSegmentClauses.join(" AND ")})`,
+    );
+  if (input.agent) {
+    clauses.push("i.zaip_agent = ?");
+    values.push(input.agent);
+  }
+  if (input.phase) {
+    clauses.push("i.phase = ?");
+    values.push(input.phase);
+  }
+  if (input.status) {
+    clauses.push("i.status = ?");
+    values.push(input.status);
+  }
+  if (input.priority) {
+    // Canonical task priority is not materialized in this read model.
+    // Do not substitute a different attribute for it.
+    clauses.push("0");
+  }
+  if (input.risk) {
+    clauses.push("i.task_risk = ?");
+    values.push(input.risk);
+  }
+  if (input.origin) {
+    clauses.push(
+      input.origin === "prd"
+        ? "i.prd_id IS NOT NULL"
+        : input.origin === "spec"
+          ? "i.prd_id IS NULL AND i.spec_id IS NOT NULL"
+          : input.origin === "task"
+            ? "i.prd_id IS NULL AND i.spec_id IS NULL AND i.task_id IS NOT NULL"
+            : "i.prd_id IS NULL AND i.spec_id IS NULL AND i.task_id IS NULL",
+    );
+  }
+  // Invocation facts carry no canonical work_type attribution.
+  if (input.workType) clauses.push("0");
+  if (input.query) {
+    const pattern = `%${input.query}%`;
+    clauses.push(
+      "(i.agent_invocation_id LIKE ? OR i.execution_id LIKE ? OR i.task_id LIKE ? OR i.spec_id LIKE ? OR i.prd_id LIKE ? OR i.conversation_id LIKE ? OR i.zaip_agent LIKE ? OR i.purpose LIKE ?)",
+    );
+    values.push(pattern, pattern, pattern, pattern, pattern, pattern, pattern, pattern);
+  }
+  const facts = `WITH usage_rollup AS (
+        SELECT agent_invocation_id,
+          CASE COUNT(DISTINCT provider) WHEN 0 THEN NULL WHEN 1 THEN MIN(provider) ELSE 'mixed' END AS provider_group,
+          CASE COUNT(DISTINCT model) WHEN 0 THEN NULL WHEN 1 THEN MIN(model) ELSE 'mixed' END AS model_group,
+          SUM(input_tokens) AS input_tokens, SUM(cached_input_tokens) AS cached_input_tokens,
+          SUM(output_tokens) AS output_tokens, SUM(reasoning_tokens) AS reasoning_tokens
+        FROM invocation_usage GROUP BY agent_invocation_id
+      ), facts AS (
+        -- Temporal Cost Monitor groups intentionally retain historical
+        -- financial activities that have no agent invocation id.  For modern
+        -- Agent Runs, usage_rollup remains available for provider/model
+        -- same-segment filtering; historical facts keep their own recorded
+        -- provider/model attributes.
+        SELECT v.*, v.agent_run_id AS agent_invocation_id, t.risk AS task_risk,
+          u.provider_group, u.model_group, u.input_tokens, u.cached_input_tokens,
+          u.output_tokens, u.reasoning_tokens
+        FROM activities v
+        LEFT JOIN tasks t ON t.id=v.task_id
+        LEFT JOIN usage_rollup u ON u.agent_invocation_id=v.agent_run_id
+      )`;
+  const where = clauses.join(" AND ");
+  let total_count = Number(
+    (
+      context.database
+        .prepare(
+          `${facts} SELECT COUNT(*) AS count FROM (SELECT ${groupExpression} FROM facts i WHERE ${where} GROUP BY ${groupExpression})`,
+        )
+        .get(...values) as { count: number }
+    ).count,
+  );
+  const limit = Math.min(200, Math.max(1, input.limit ?? 50));
+  const offset = Math.max(0, input.offset ?? 0);
+  const order =
+    filteredCostGroup === "day" || filteredCostGroup === "month" || filteredCostGroup === "year"
+      ? "key DESC"
+      : "total_cost_brl DESC, key";
+  let rows = context.database
+    .prepare(
+      `${facts} SELECT ${groupExpression} AS key, ${groupExpression} AS label, ${groupExpression} AS period_key, MIN(date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours')) AS start_day, MAX(date(COALESCE(i.source_started_at, i.source_occurred_at, i.occurred_at), '-3 hours')) AS end_day, COUNT(*) AS invocation_count, SUM(i.llm_call_count) AS llm_call_count, SUM(i.source_event_count) AS source_event_count, NULL AS total_duration, SUM(i.input_tokens) AS total_input_tokens, SUM(i.cached_input_tokens) AS total_cached_input_tokens, SUM(i.output_tokens) AS total_output_tokens, SUM(i.reasoning_tokens) AS total_reasoning_tokens, SUM(i.total_tokens) AS total_tokens, SUM(i.cost_usd) AS total_cost_usd, SUM(i.cost_brl) AS total_cost_brl FROM facts i WHERE ${where} GROUP BY ${groupExpression} ORDER BY ${order} LIMIT ? OFFSET ?`,
+    )
+    .all(...values, limit, offset) as Array<Record<string, unknown>>;
+  if (temporalCostGroup) {
+    const canonicalFilter = {
+      from: input.from ?? null,
+      to: input.to ?? null,
+      providers: input.provider ? [input.provider] : [],
+      models: input.model ? [input.model] : [],
+      agents: input.agent ? [input.agent] : [],
+      phases: input.phase ? [input.phase] : [],
+      statuses: input.status ? [input.status] : [],
+    };
+    const factualDuration = context.costMonitorFactualDurationByDay(canonicalFilter);
+    // Lifecycle counts are canonical facts keyed by their own occurrence
+    // date. They deliberately do not inherit financial dimensions.
+    const hasUnsupportedLifecycleAttribution = Boolean(
+      input.origin || input.priority || input.risk || input.workType,
+    );
+    const lifecycleRows = hasUnsupportedLifecycleAttribution
+      ? []
+      : (context.database
+          .prepare(`SELECT day, prd_count, spec_count, task_count, validation_count, evidence_count
+                FROM daily_aggregate_cache WHERE (? IS NULL OR day >= ?) AND (? IS NULL OR day <= ?)`)
+          .all(
+            costMonitorFilterDay(input.from),
+            costMonitorFilterDay(input.from),
+            costMonitorFilterDay(input.to),
+            costMonitorFilterDay(input.to),
+          ) as Array<Record<string, unknown>>);
+    const lifecycleByKey = new Map<string, Record<string, number>>();
+    for (const row of lifecycleRows) {
+      const day = String(row.day);
+      const key =
+        filteredCostGroup === "day"
+          ? day
+          : filteredCostGroup === "month"
+            ? day.slice(0, 7)
+            : day.slice(0, 4);
+      const target = lifecycleByKey.get(key) ?? {
+        prd_count: 0,
+        spec_count: 0,
+        task_count: 0,
+        validation_count: 0,
+        evidence_count: 0,
+      };
+      for (const column of [
+        "prd_count",
+        "spec_count",
+        "task_count",
+        "validation_count",
+        "evidence_count",
+      ] as const)
+        target[column] = (target[column] ?? 0) + Number(row[column] ?? 0);
+      lifecycleByKey.set(key, target);
+    }
+    const financialByKey = new Map(rows.map((row) => [String(row.period_key), row]));
+    const canonicalKeys = new Set(
+      (input.query
+        ? []
+        : [...new Set([...factualDuration.keys(), ...lifecycleRows.map((row) => String(row.day))])]
+      ).map((day) =>
+        filteredCostGroup === "day"
+          ? day
+          : filteredCostGroup === "month"
+            ? day.slice(0, 7)
+            : day.slice(0, 4),
+      ),
+    );
+    const keys = [...new Set([...financialByKey.keys(), ...canonicalKeys])].sort((a, b) =>
+      b.localeCompare(a),
+    );
+    const allRows = keys.map((key) => {
+      const financial = financialByKey.get(key) ?? {
+        key,
+        label: key,
+        period_key: key,
+        start_day: key,
+        end_day: key,
+        invocation_count: 0,
+        llm_call_count: null,
+        source_event_count: 0,
+        total_tokens: null,
+        total_cost_usd: null,
+        total_cost_brl: null,
+      };
+      const dayMatches = (day: string) =>
+        filteredCostGroup === "day" ? day === key : day.startsWith(key);
+      const durationMatches = [...factualDuration].filter(([day]) => dayMatches(day));
+      return {
+        ...financial,
+        ...(lifecycleByKey.get(key) ??
+          (hasUnsupportedLifecycleAttribution
+            ? {
+                prd_count: null,
+                spec_count: null,
+                task_count: null,
+                validation_count: null,
+                evidence_count: null,
+              }
+            : {
+                prd_count: 0,
+                spec_count: 0,
+                task_count: 0,
+                validation_count: 0,
+                evidence_count: 0,
+              })),
+        total_run_count: Number(financial.invocation_count ?? 0),
+        total_duration:
+          durationMatches.length === 0 ||
+          durationMatches.some(([, duration]) => duration.eligible_runs !== duration.known_runs)
+            ? null
+            : durationMatches.reduce((sum, [, duration]) => sum + duration.known_sum, 0),
+      };
+    });
+    total_count = allRows.length;
+    rows = allRows.slice(offset, offset + limit);
+    for (const row of rows) {
+      const key = String(row.period_key);
+      const matchingDays = [...factualDuration.keys()].filter((day) =>
+        filteredCostGroup === "day" ? day === key : day.startsWith(key),
+      );
+      if (matchingDays.length > 0) {
+        row.start_day = matchingDays.sort()[0];
+        row.end_day = matchingDays.sort().at(-1);
+      }
+    }
+  }
+  return {
+    data_source: "sqlite_read_model" as const,
+    view,
+    offset,
+    limit,
+    total_count,
+    has_more: offset + rows.length < total_count,
+    rows,
+  };
+}