@agent-native/core 0.98.2 → 0.98.4

package/corpus/templates/analytics/app/components/layout/command-palette-search.ts

@@ -26,3 +26,96 @@ export function commandPaletteKeywords(
 
   return Array.from(variants);
 }
+
+function normalizeSearchText(value: string): string {
+  return value
+    .normalize("NFKD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}]+/gu, " ")
+    .trim();
+}
+
+function fuzzySubsequenceScore(candidate: string, query: string): number {
+  const compactCandidate = candidate.replace(/\s/g, "");
+  const compactQuery = query.replace(/\s/g, "");
+  let queryIndex = 0;
+
+  for (const character of compactCandidate) {
+    if (character === compactQuery[queryIndex]) queryIndex += 1;
+    if (queryIndex === compactQuery.length) {
+      return 0.2 * (compactQuery.length / compactCandidate.length);
+    }
+  }
+
+  return 0;
+}
+
+export function commandPaletteFilter(
+  value: string,
+  search: string,
+  keywords: string[] = [],
+): number {
+  const query = normalizeSearchText(search);
+  if (!query) return 1;
+
+  const queryWords = query.split(" ");
+  let bestScore = 0;
+
+  for (const rawCandidate of [...keywords, value]) {
+    const candidate = normalizeSearchText(rawCandidate);
+    if (!candidate) continue;
+
+    const words = candidate.split(" ");
+    let score = 0;
+
+    if (candidate === query) score = 1;
+    else if (candidate.startsWith(query)) score = 0.96;
+    else if (words.includes(query)) score = 0.94;
+    else if (words.some((word) => word.startsWith(query))) score = 0.9;
+    else if (candidate.includes(query)) score = 0.8;
+    else if (
+      queryWords.every((queryWord) =>
+        words.some((word) => word.startsWith(queryWord)),
+      )
+    ) {
+      score = 0.72;
+    } else {
+      score = fuzzySubsequenceScore(candidate, query);
+    }
+
+    bestScore = Math.max(bestScore, score);
+  }
+
+  return bestScore;
+}
+
+export function rankCommandPaletteEntries<T>(
+  entries: T[],
+  search: string,
+  getSearchData: (entry: T) => { value: string; keywords?: string[] },
+): Array<{ entry: T; score: number }> {
+  return entries
+    .map((entry, index) => {
+      const { value, keywords } = getSearchData(entry);
+      return {
+        entry,
+        index,
+        score: commandPaletteFilter(value, search, keywords),
+      };
+    })
+    .filter(({ score }) => score > 0)
+    .sort((a, b) => b.score - a.score || a.index - b.index)
+    .map(({ entry, score }) => ({ entry, score }));
+}
+
+export function uniqueCommandItems<T extends { id: string; name: string }>(
+  items: T[],
+): T[] {
+  const seenIds = new Set<string>();
+  return items.filter((item) => {
+    if (seenIds.has(item.id)) return false;
+    seenIds.add(item.id);
+    return true;
+  });
+}

package/corpus/templates/analytics/app/global.css

@@ -245,72 +245,14 @@
   transform-origin: top left;
 }
 
-/* First-party visitor-cursor styles for rrweb playback. These are bundled
-   statically so the cursor stays visible even if the lazily imported
-   `@rrweb/replay/dist/style.css` sheet fails to load, and they replace the
-   default black arrow sprite with an app-styled indicator. The cursor lives
-   inside `.replayer-wrapper`, so it scales with the fit-to-stage transform. */
-.an-replay-stage-root .replayer-mouse {
-  position: absolute;
-  z-index: 2;
-  width: 1.125rem;
-  height: 1.5rem;
-  border-radius: 0;
-  background: transparent;
-  background-image: none;
-  box-shadow: none;
-  transform: none;
-  transition:
-    left 80ms linear,
-    top 80ms linear;
-  pointer-events: none;
-}
-
-.an-replay-stage-root .replayer-mouse::before {
-  content: "";
-  position: absolute;
-  inset: 0;
-  background: hsl(0 0% 100%);
-  clip-path: polygon(0 0, 0 77%, 30% 57%, 48% 100%, 68% 92%, 50% 51%, 92% 51%);
-  filter: drop-shadow(0 0 1px hsl(0 0% 0% / 0.95))
-    drop-shadow(0 1px 3px hsl(0 0% 0% / 0.35));
-}
-
+/* IMPORTANT: Keep rrweb's stock SVG arrow. Only suppress its permanently
+   visible purple ::after disc, which can otherwise read as the cursor itself
+   when the arrow is small. The stock .active animation still supplies the
+   brief click halo. Do not replace the arrow with an app-colored dot. */
 .an-replay-stage-root .replayer-mouse::after {
-  content: "";
-  position: absolute;
-  left: -0.5rem;
-  top: -0.5rem;
-  width: 1rem;
-  height: 1rem;
-  border-radius: 9999px;
-  border: 2px solid hsl(217 91% 60%);
-  background: transparent;
   opacity: 0;
 }
 
-/* rrweb toggles `.active` on mouse interactions; pulse a click ripple. */
-.an-replay-stage-root .replayer-mouse.active::after {
-  animation: an-replay-mouse-click 0.4s ease-out 1;
-}
-
-@keyframes an-replay-mouse-click {
-  0% {
-    opacity: 0.5;
-    transform: scale(1);
-  }
-  100% {
-    opacity: 0;
-    transform: scale(3.5);
-  }
-}
-
-.an-replay-stage-root .replayer-mouse-tail {
-  position: absolute;
-  inset: 0;
-  pointer-events: none;
-}
-
 .analytics-session-snippet .plan-code-surface {
   border: 0;
   border-radius: 0;

package/corpus/templates/analytics/app/hooks/use-replay-storage-status.ts

@@ -46,11 +46,12 @@ export async function fetchReplayStorageStatus(): Promise<ReplayStorageStatus> {
   };
 }
 
-export function useReplayStorageStatus() {
+export function useReplayStorageStatus(options?: { enabled?: boolean }) {
   return useQuery({
     queryKey: REPLAY_STORAGE_STATUS_KEY,
     queryFn: fetchReplayStorageStatus,
     staleTime: 60_000,
+    enabled: options?.enabled,
   });
 }
 

package/corpus/templates/analytics/app/lib/demo-chart-trend.ts

@@ -52,49 +52,56 @@ function normalizedVolatility(
 }
 
 function normalizedTrend(
-  length: number,
+  series: number[],
+  minimum: number,
+  range: number,
   volatilityScore: number,
   random: () => number,
 ): number[] {
+  const length = series.length;
   if (length <= 1) return [0];
   if (length === 2) return [0, 1];
 
-  const volatility = 0.015 + volatilityScore * (0.22 + random() * 0.12);
-  const noiseMemory = 0.78 - volatilityScore * 0.58;
-  let noise = 0;
-  const values = Array.from({ length }, (_, index) => {
-    if (index === 0) return 0;
-    if (index === length - 1) return 1;
+  const normalized = series.map((value) => (value - minimum) / range);
+  const randomization = 0.012 + volatilityScore * 0.08;
+  const shape = [normalized[0]];
+
+  // Preserve the source's actual step pattern (including when and how sharply
+  // it spikes), with just enough seeded variation that otherwise-similar demo
+  // series do not become identical. Smooth sources receive almost no jitter;
+  // volatile sources can vary a little more without moving their events.
+  for (let index = 1; index < length; index += 1) {
+    const sourceStep = normalized[index] - normalized[index - 1];
+    const factor = 1 + (random() * 2 - 1) * randomization;
+    shape.push(shape[index - 1] + sourceStep * factor);
+  }
 
+  // Add only the linear drift required for the first point to be the global
+  // minimum and the last to be the global maximum. A linear term has zero
+  // second difference, so the source's local acceleration, spikes, and dips
+  // survive instead of being replaced by a synthetic random walk.
+  let requiredDrift = 0;
+  for (let index = 1; index < length; index += 1) {
+    const progress = index / (length - 1);
+    requiredDrift = Math.max(
+      requiredDrift,
+      (shape[0] - shape[index]) / progress,
+    );
+  }
+  for (let index = 0; index < length - 1; index += 1) {
     const progress = index / (length - 1);
-    noise = noise * noiseMemory + (random() * 2 - 1) * (1 - noiseMemory);
-    const taperedNoise = noise * volatility * Math.sin(Math.PI * progress);
-    return clamp(progress + taperedNoise, 0.025, 0.975);
-  });
-
-  // Pullback count and depth follow the source's normalized volatility. A
-  // smooth source remains a gentle rise; a jagged source gets several seeded
-  // reversals. Spacing the reversals across the series prevents them from
-  // collapsing into one noisy patch.
-  if (length >= 5 && volatilityScore >= 0.12) {
-    const maximumPullbacks = Math.min(3, Math.floor((length - 2) / 2));
-    const pullbackCount = Math.max(
-      1,
-      Math.round(volatilityScore * maximumPullbacks),
+    requiredDrift = Math.max(
+      requiredDrift,
+      (shape[index] - shape[length - 1]) / (1 - progress),
     );
-    for (let pullback = 0; pullback < pullbackCount; pullback += 1) {
-      const segmentCenter =
-        ((pullback + 1) * (length - 3)) / (pullbackCount + 1) + 1;
-      const jitter = (random() - 0.5) * Math.max(1, length / 10);
-      const dipIndex = Math.round(clamp(segmentCenter + jitter, 2, length - 2));
-      const center = dipIndex / (length - 1);
-      const amplitude = 0.025 + volatilityScore * (0.075 + random() * 0.12);
-      values[dipIndex - 1] = clamp(center + amplitude, 0.075, 0.925);
-      values[dipIndex] = clamp(center - amplitude, 0.05, 0.9);
-    }
   }
 
-  return values;
+  const drift = requiredDrift + 0.012 + random() * 0.018;
+  const candidate = shape.map(
+    (value, index) => value + drift * (index / (length - 1)),
+  );
+  const candidateRange = candidate[length - 1] - candidate[0];
+  return candidate.map((value) => (value - candidate[0]) / candidateRange);
 }
 
 /**
@@ -133,7 +140,13 @@ export function createDemoChartTrendRows(
       minimum,
       range,
     );
-    const trend = normalizedTrend(points.length, volatilityScore, random);
+    const trend = normalizedTrend(
+      points.map((point) => point.numeric),
+      minimum,
+      range,
+      volatilityScore,
+      random,
+    );
     const useStringValues = points.every(
       (point) => typeof point.original === "string",
     );

package/corpus/templates/analytics/app/pages/Settings.tsx

@@ -5,7 +5,6 @@ import {
   useAgentSettingsTabs,
   useSession,
   useT,
-  type SettingsSearchEntry,
   type SettingsTabItem,
 } from "@agent-native/core/client";
 import { TeamPage } from "@agent-native/core/client/org";
@@ -27,6 +26,7 @@ import changelog from "../../CHANGELOG.md?raw";
 import { useReplayStorageStatus } from "../hooks/use-replay-storage-status";
 import { ReplayStorageHint } from "./sessions/SessionsPage";
 import { AlertRulesSettingsCard } from "./settings/AlertRulesSettingsCard";
+import { buildAnalyticsGeneralSettingsSearchEntries } from "./settings/settings-search";
 
 export default function Settings() {
   // Settings is also reachable directly from the full-page agent surface.
@@ -56,49 +56,12 @@ export default function Settings() {
     [agentSettingsTabs, t],
   );
 
-  const generalSearchEntries = useMemo<SettingsSearchEntry[]>(
-    () => [
-      {
-        id: "analytics-account",
-        label: t("settings.account"),
-        keywords: "profile email signed in identity",
-        hash: "account",
-      },
-      {
-        id: "analytics-credentials",
-        label: t("settings.credentials"),
-        keywords: "data sources api keys manage credentials",
-        hash: "credentials",
-      },
-      {
-        id: "analytics-dashboard-templates",
-        label: t("settings.dashboardTemplates"),
-        keywords: "templates catalog dashboards",
-        hash: "dashboard-templates",
-      },
-      ...(replayStorageStatus.data?.configured
-        ? [
-            {
-              id: "analytics-replay-storage",
-              label: t("sessions.storageSetupTitle"),
-              keywords: "session replay recording storage s3 bucket builder",
-              hash: "replay-storage",
-            },
-          ]
-        : []),
-      {
-        id: "analytics-language",
-        label: t("settings.languageTitle"),
-        keywords: "language locale translation i18n",
-        hash: "language",
-      },
-      {
-        id: "analytics-about",
-        label: t("settings.about"),
-        keywords: "about version info usage",
-        hash: "about",
-      },
-    ],
+  const generalSearchEntries = useMemo(
+    () =>
+      buildAnalyticsGeneralSettingsSearchEntries(
+        t,
+        !!replayStorageStatus.data?.configured,
+      ),
     [replayStorageStatus.data?.configured, t],
   );
 
@@ -184,7 +147,7 @@ export default function Settings() {
                 </CardDescription>
               </CardHeader>
               <CardContent>
-                <ReplayStorageHint />
+                <ReplayStorageHint embedded />
               </CardContent>
             </Card>
           ) : null}