npm - @agent-native/core - Versions diffs - 0.122.0 → 0.122.2 - Mend

@agent-native/core 0.122.0 → 0.122.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (187) hide show

package/corpus/core/src/vite/client.ts CHANGED Viewed

@@ -2414,6 +2414,10 @@ type NitroModuleGraph = {
 const NITRO_STARTUP_SETTLE_MS = 1_000;
 const NITRO_STARTUP_TIMEOUT_MS = 30_000;
+const NITRO_STARTUP_RETRY_KEY = "__agent_native_nitro_startup_retry";
+const NITRO_STARTUP_RETRY_MAX = 5;
+const NITRO_STARTUP_RETRY_DELAY_MS = 1_000;
+const NITRO_STARTUP_RETRY_RESET_MS = 15_000;
 function nitroModuleGraphSignature(environment: unknown): string | null {
   const graph = (environment as { moduleGraph?: NitroModuleGraph } | undefined)
@@ -2456,9 +2460,66 @@ function sendNitroStartingResponse(
     res.end();
     return;
   }
-  res.end(
-    '<!doctype html><html><head><meta charset="utf-8"><meta http-equiv="refresh" content="0.25"><title>Starting…</title></head><body></body></html>',
-  );
+  res.end(`<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Dev server restarting…</title>
+    <style>
+      body { margin: 0; min-height: 100vh; display: grid; place-items: center; font: 16px/1.5 system-ui, sans-serif; color: #171717; background: #fafafa; }
+      main { width: min(560px, calc(100vw - 48px)); }
+      h1 { margin: 0 0 8px; font-size: 1.25rem; }
+      p { margin: 0; color: #737373; }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>Dev server is restarting…</h1>
+      <p id="agent-native-nitro-retry-status">Checking again shortly.</p>
+    </main>
+    <script>
+      (() => {
+        const key = ${JSON.stringify(NITRO_STARTUP_RETRY_KEY)};
+        const maxRetries = ${NITRO_STARTUP_RETRY_MAX};
+        const resetAfterMs = ${NITRO_STARTUP_RETRY_RESET_MS};
+        const retryDelayMs = ${NITRO_STARTUP_RETRY_DELAY_MS};
+        const status = document.getElementById("agent-native-nitro-retry-status");
+        const now = Date.now();
+        let count = 0;
+        let lastAttemptAt = 0;
+        try {
+          const stored = JSON.parse(sessionStorage.getItem(key) || "null");
+          if (stored && typeof stored === "object") {
+            count = Number.isFinite(stored.count) ? stored.count : 0;
+            lastAttemptAt = Number.isFinite(stored.at) ? stored.at : 0;
+          }
+        } catch (error) {
+          // A blocked session store is handled below by showing a manual retry.
+        }
+        if (now - lastAttemptAt > resetAfterMs) count = 0;
+        if (count >= maxRetries) {
+          if (status) status.textContent = "The server is still unavailable. Refresh when it is ready.";
+          return;
+        }
+        const nextState = JSON.stringify({ count: count + 1, at: now });
+        try {
+          sessionStorage.setItem(key, nextState);
+          if (sessionStorage.getItem(key) !== nextState) throw new Error("unavailable");
+        } catch (error) {
+          if (status) status.textContent = "Refresh manually when the server is ready.";
+          return;
+        }
+        if (status) status.textContent = "Retrying in one second…";
+        setTimeout(() => window.location.reload(), retryDelayMs);
+      })();
+    </script>
+  </body>
+</html>`);
 }
 function nitroStartupGate(

package/corpus/templates/analytics/.agents/skills/dashboard-management/SKILL.md CHANGED Viewed

@@ -84,6 +84,21 @@ Do not rely on undeclared time variables. Server validation rejects unbound
 first-party SQL, so declare the filter or choose an explicit non-dashboard
 scope before saving.
+**A bound anywhere in the SQL is not the same as every CTE having its own
+bound.** If a panel has multiple top-level CTEs (`WITH a AS (...), b AS
+(...)`) and more than one of them reads `analytics_events`, EVERY one of
+those CTEs needs its own `{{timeRange}}`/`{{<id>Start}}`/`{{<id>End}}`
+reference or literal date bound — not just the final `SELECT` or one sibling
+CTE. A CTE that computes something like "this user's first-ever active day"
+by scanning `analytics_events` with no bound at all will full-table-scan on
+every render even though the panel *looks* time-bound overall (root cause of
+a 2026-07-25 production incident: several dashboards had exactly this shape).
+Server validation checks each top-level CTE independently now, so this fails
+at save time — but write it right the first time: bound every CTE, or use
+`config.timeScope: "cohort-history"` only for a CTE that is genuinely
+defining a cohort (e.g. a first-seen date), never as a way to skip bounding
+an ordinary activity scan.
 ## Creating A Dashboard
 When the user asks for a dashboard:

package/corpus/templates/analytics/app/components/layout/Sidebar.tsx CHANGED Viewed

@@ -19,14 +19,12 @@ import {
   IconLock,
   IconLink,
   IconMessageCircle,
-  IconHierarchy2,
   IconUsersGroup,
   IconEye,
   IconEyeOff,
   IconPlayerPlay,
   IconLayoutSidebarLeftCollapse,
   IconLayoutSidebarLeftExpand,
-  IconArrowUpRight,
 } from "@tabler/icons-react";
 import {
   useQuery,
@@ -183,12 +181,6 @@ import {
 import { CSS } from "@dnd-kit/utilities";
 const bottomItems = [
-  {
-    icon: IconHierarchy2,
-    labelKey: "settings.agentTitle",
-    href: "/agent",
-    showExternalLinkIcon: true,
-  },
   { icon: IconSettings, labelKey: "navigation.settings", href: "/settings" },
 ];
@@ -2098,12 +2090,6 @@ export function Sidebar({ mobile }: { mobile?: boolean } = {}) {
       href: "/data-dictionary",
       active: location.pathname.startsWith("/data-dictionary"),
     },
-    {
-      icon: IconHierarchy2,
-      label: t("settings.agentTitle"),
-      href: "/agent",
-      active: location.pathname === "/agent",
-    },
     {
       icon: IconSettings,
       label: t("navigation.settings"),
@@ -2572,15 +2558,7 @@ export function Sidebar({ mobile }: { mobile?: boolean } = {}) {
                       )}
                     >
                       <Icon className="h-4 w-4" />
-                      <span className="flex min-w-0 items-center gap-1">
-                        <span className="truncate">{t(item.labelKey)}</span>
-                        {item.showExternalLinkIcon && (
-                          <IconArrowUpRight
-                            aria-hidden="true"
-                            className="h-3.5 w-3.5 shrink-0 text-muted-foreground/70"
-                          />
-                        )}
-                      </span>
+                      <span className="truncate">{t(item.labelKey)}</span>
                     </Link>
                   );
                 })}

package/corpus/templates/analytics/app/pages/adhoc/sql-dashboard/report-panel-window.ts CHANGED Viewed

@@ -1,8 +1,8 @@
-import { MAX_CONCURRENT_SQL_QUERIES } from "@shared/sql-query-limits";
 import type { SqlPanel } from "./types";
-export const REPORT_PANEL_CHUNK_SIZE = MAX_CONCURRENT_SQL_QUERIES;
+// Keep each report window within the browser-side SQL query concurrency limit
+// so a cold window does not serialize into multiple waves before readiness.
+export const REPORT_PANEL_CHUNK_SIZE = 4;
 export function listReportablePanelIds(panels: SqlPanel[]): string[] {
   return panels

package/corpus/templates/analytics/app/routes/_index.tsx CHANGED Viewed

@@ -1,7 +1,7 @@
 import { redirect, type LoaderFunctionArgs } from "react-router";
 const SEO_TITLE =
-  "Agent-Native Analytics - Open Source Alternative to Amplitude & FullStory";
+  "Analytics - Open Source Alternative to Amplitude & FullStory";
 const SEO_DESCRIPTION =
   "Open Source analytics app and alternative to Amplitude and FullStory where AI agents connect to warehouses, product analytics, and CRM data to answer questions and build dashboards.";

package/corpus/templates/analytics/changelog/2026-07-25-analytics-dashboards-and-scheduled-reports-are-faster-and-mo.md ADDED Viewed

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-25
+---
+Analytics dashboards and scheduled reports are faster and more reliable with large event histories.

package/corpus/templates/analytics/changelog/2026-07-25-app-branding-now-uses-the-product-name-without-the-agent-nat.md ADDED Viewed

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-25
+---
+App branding now uses the product name without the Agent-Native prefix.

package/corpus/templates/analytics/changelog/2026-07-25-settings-navigation-now-keeps-manage-agent-as-a-dedicated-li.md ADDED Viewed

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-25
+---
+Settings navigation now keeps Manage agent as a dedicated linked destination at the bottom.

package/corpus/templates/analytics/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "analytics",
-  "displayName": "Agent-Native Analytics",
+  "displayName": "Analytics",
   "private": true,
   "type": "module",
   "scripts": {

package/corpus/templates/analytics/public/manifest.json CHANGED Viewed

@@ -1,5 +1,5 @@
 {
-  "name": "Agent Native Analytics",
+  "name": "Analytics",
   "short_name": "Analytics",
   "description": "Analytics dashboard",
   "start_url": ".",

package/corpus/templates/analytics/server/db/schema.ts CHANGED Viewed

@@ -193,6 +193,18 @@ export const bigqueryCache = table("bigquery_cache", {
   expiresAt: text("expires_at").notNull(),
 });
+/**
+ * First-party dashboard panel result cache — see
+ * server/lib/first-party-analytics-cache.ts.
+ */
+export const firstPartyAnalyticsCache = table("first_party_analytics_cache", {
+  key: text("key").primaryKey(),
+  sql: text("sql").notNull(),
+  result: text("result").notNull(),
+  createdAt: text("created_at").notNull(),
+  expiresAt: text("expires_at").notNull(),
+});
 /**
  * Public write keys for the first-party analytics ingestion endpoint.
  * The key is intentionally public/write-only: it can create events for the

package/corpus/templates/analytics/server/lib/dashboard-panel-query.ts CHANGED Viewed

@@ -446,10 +446,14 @@ export async function runDashboardPanelQuery(args: {
   }
   if (source === "first-party") {
-    return await queryFirstPartyAnalytics(query, {
-      userEmail: ctx.userEmail,
-      orgId: ctx.orgId ?? null,
-    });
+    return await queryFirstPartyAnalytics(
+      query,
+      {
+        userEmail: ctx.userEmail,
+        orgId: ctx.orgId ?? null,
+      },
+      { cache: true },
+    );
   }
   if (source === "demo") {

package/corpus/templates/analytics/server/lib/dashboard-report.ts CHANGED Viewed

@@ -15,6 +15,8 @@ import {
   EMBED_TOKEN_QUERY_PARAM,
 } from "@agent-native/core/shared";
+import { interpolate } from "../../app/pages/adhoc/sql-dashboard/interpolate";
+import { serializePanelSql } from "../../app/pages/adhoc/sql-dashboard/panel-sql";
 import {
   listReportablePanelIds,
   REPORT_PANEL_CHUNK_SIZE,
@@ -32,6 +34,7 @@ import {
   type DashboardReportCaptureOutcome,
   type DashboardReportSubscription,
 } from "./dashboard-report-subscriptions";
+import { queryFirstPartyAnalytics } from "./first-party-analytics.js";
 type ReportSnapshot = {
   dashboardId: string;
@@ -42,6 +45,8 @@ type ReportSnapshot = {
   reportSettingsUrl: string;
   generatedAt: string;
   panelIds: string[];
+  panels: SqlDashboardConfig["panels"];
+  variables?: Record<string, string>;
 };
 const DATE_FILTER_TYPES: ReadonlySet<FilterType> = new Set([
@@ -58,7 +63,9 @@ const LOCAL_SCREENSHOT_TIMEOUT_MS = 90_000;
 const SERVERLESS_SCREENSHOT_TIMEOUT_MS = 90_000;
 const SERVERLESS_SECOND_READY_TIMEOUT_MS = 45_000;
 // Cap browser work separately from the sweep-level delivery deadline.
-const SERVERLESS_CHUNKED_ATTEMPT_TIMEOUT_MS = 150_000;
+// Reserve time under Netlify's 300s background-function limit for cleanup and
+// email delivery (see MAX_CAPTURE_CLEANUP_RESERVE_MS / delivery reserves below).
+const SERVERLESS_CHUNKED_ATTEMPT_TIMEOUT_MS = 210_000;
 const BROWSER_CLEANUP_TIMEOUT_MS = 10_000;
 const DASHBOARD_REPORT_EMAIL_TIMEOUT_MS = 10_000;
 const DASHBOARD_REPORT_EMAIL_OVERHEAD_RESERVE_MS = 5_000;
@@ -226,6 +233,8 @@ async function collectReportSnapshot(
     }),
     generatedAt: new Date().toISOString(),
     panelIds: listReportablePanelIds(config.panels),
+    panels: config.panels,
+    variables: config.variables,
   };
 }
@@ -375,6 +384,14 @@ function boundedStageTimeout(capMs: number, deadlineAt?: number): number {
   return Math.max(1, Math.min(capMs, remainingMs));
 }
+function reportDeliveryReserveMs(recipientCount: number): number {
+  return (
+    MAX_CAPTURE_CLEANUP_RESERVE_MS +
+    recipientCount * DASHBOARD_REPORT_EMAIL_TIMEOUT_MS +
+    DASHBOARD_REPORT_EMAIL_OVERHEAD_RESERVE_MS
+  );
+}
 async function runWithinCaptureDeadline<T>(
   operation: () => Promise<T>,
   deadlineAt?: number,
@@ -448,7 +465,15 @@ async function waitForDashboardReportReady(
         if (root.getAttribute("data-dashboard-report-ready") !== "true") {
           return false;
         }
-        return !root.querySelector("[data-dashboard-report-loading='true']");
+        if (root.querySelector("[data-dashboard-report-loading='true']")) {
+          return false;
+        }
+        // A panel that errored (including its own query-call timeout) clears
+        // its loading marker just like a successful panel, so without this
+        // check the capture would treat a broken panel as "ready" and bake
+        // its raw error text into the delivered screenshot instead of
+        // failing the attempt so the retry sweep can pick it up.
+        return !root.querySelector("[role='alert']");
       })()`,
       undefined,
       { timeout },
@@ -505,6 +530,101 @@ async function waitForDashboardReportReady(
   }
 }
+const PREWARM_CONCURRENCY = 3;
+const PREWARM_PANEL_TIMEOUT_MS = 20_000;
+const PREWARM_MAX_BUDGET_MS = 45_000;
+/**
+ * Runs first-party panel queries once, directly, before the browser capture
+ * starts, so the capture's own query-dashboard-panel calls hit a warm cache
+ * instead of several panels racing each other cold for database time inside
+ * a single capture window — that contention, not any one query alone, is
+ * what was pushing panels past their capture timeout. Best-effort: a panel
+ * that fails or times out here is simply computed cold by the capture later,
+ * exactly as it always was, so this can never make a report worse than
+ * before it existed. Bounded to time left after reserving the full chunked
+ * capture attempt and delivery tail, so prewarming cannot starve capture.
+ * The per-panel timeout only bounds how long a worker waits before logging;
+ * it is also passed to the database/cache layers, and the original query is
+ * still awaited before this function returns so it cannot overlap capture.
+ */
+async function prewarmFirstPartyPanelCache(
+  sub: DashboardReportSubscription,
+  snapshot: ReportSnapshot,
+  deadlineAt?: number,
+  recipientCount = 0,
+): Promise<void> {
+  const panels = (snapshot.panels ?? []).filter(
+    (panel) => panel.source === "first-party" && panel.sql != null,
+  );
+  if (!panels.length) return;
+  const remaining = deadlineAt ? deadlineAt - Date.now() : Infinity;
+  const budgetMs = Math.max(
+    0,
+    Math.min(
+      PREWARM_MAX_BUDGET_MS,
+      deadlineAt
+        ? remaining -
+            SERVERLESS_CHUNKED_ATTEMPT_TIMEOUT_MS -
+            reportDeliveryReserveMs(recipientCount)
+        : PREWARM_MAX_BUDGET_MS,
+    ),
+  );
+  if (budgetMs <= 0) return;
+  const prewarmDeadline = Date.now() + budgetMs;
+  const vars: Record<string, string> = { ...snapshot.variables };
+  for (const [key, value] of Object.entries(snapshot.filters)) {
+    if (key.startsWith("f_")) vars[key.slice(2)] = value;
+  }
+  const scope = { userEmail: sub.ownerEmail, orgId: sub.orgId ?? null };
+  let index = 0;
+  async function worker(): Promise<void> {
+    while (index < panels.length && Date.now() < prewarmDeadline) {
+      const panel = panels[index++];
+      const sql = interpolate(serializePanelSql(panel.sql), vars, {
+        failClosedTimeVariables: true,
+      });
+      if (!sql.trim()) continue;
+      const panelTimeoutMs = Math.max(
+        1,
+        Math.min(PREWARM_PANEL_TIMEOUT_MS, prewarmDeadline - Date.now()),
+      );
+      const query = queryFirstPartyAnalytics(sql, scope, {
+        cache: true,
+        timeoutMs: panelTimeoutMs,
+      });
+      let timeout: ReturnType<typeof setTimeout> | undefined;
+      try {
+        await Promise.race([
+          query,
+          new Promise<never>((_, reject) => {
+            timeout = setTimeout(
+              () => reject(new Error("prewarm panel timeout")),
+              panelTimeoutMs,
+            );
+            timeout.unref?.();
+          }),
+        ]);
+      } catch (err) {
+        console.warn(
+          `[dashboard-report] prewarm failed for panel ${panel.id}:`,
+          err instanceof Error ? err.message : err,
+        );
+      } finally {
+        if (timeout) clearTimeout(timeout);
+        await query.catch(() => undefined);
+      }
+    }
+  }
+  await Promise.all(
+    Array.from({ length: PREWARM_CONCURRENCY }, () => worker()),
+  );
+}
 async function assertDashboardReportPanelWindow(
   page: any,
   expectedPanelIds: string[],
@@ -1358,14 +1478,25 @@ export async function sendDashboardReportSubscription(
     () => collectReportSnapshot(sub),
     options.deadlineAt,
   );
+  try {
+    await prewarmFirstPartyPanelCache(
+      sub,
+      snapshot,
+      options.deadlineAt,
+      recipients.length,
+    );
+  } catch (err) {
+    console.warn(
+      "[dashboard-report] panel cache prewarm failed (non-fatal):",
+      err instanceof Error ? err.message : err,
+    );
+  }
   const captureTimeoutMs = options.deadlineAt
     ? Math.min(
         SERVERLESS_CHUNKED_ATTEMPT_TIMEOUT_MS,
         options.deadlineAt -
           Date.now() -
-          MAX_CAPTURE_CLEANUP_RESERVE_MS -
-          recipients.length * DASHBOARD_REPORT_EMAIL_TIMEOUT_MS -
-          DASHBOARD_REPORT_EMAIL_OVERHEAD_RESERVE_MS,
+          reportDeliveryReserveMs(recipients.length),
       )
     : undefined;
   const capture = await captureDashboardPngWithFallback(