@agent-native/core 0.98.1 → 0.98.3

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/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

@@ -0,0 +1,169 @@
+type DemoTrendSeed = string | number;
+
+function hashSeed(seed: string): number {
+  let hash = 2166136261;
+  for (let index = 0; index < seed.length; index += 1) {
+    hash ^= seed.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+
+function createRandom(seed: string): () => number {
+  let state = hashSeed(seed);
+  return () => {
+    state += 0x6d2b79f5;
+    let value = state;
+    value = Math.imul(value ^ (value >>> 15), value | 1);
+    value ^= value + Math.imul(value ^ (value >>> 7), value | 61);
+    return ((value ^ (value >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+function clamp(value: number, minimum: number, maximum: number): number {
+  return Math.min(maximum, Math.max(minimum, value));
+}
+
+function numericValue(value: unknown): number | null {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value !== "string" || value.trim() === "") return null;
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+}
+
+function normalizedVolatility(
+  series: number[],
+  minimum: number,
+  range: number,
+) {
+  if (series.length < 3 || range === 0) return 0;
+  const normalized = series.map((value) => (value - minimum) / range);
+  const averageStep =
+    (normalized[normalized.length - 1] - normalized[0]) /
+    (normalized.length - 1);
+  const deviation = normalized
+    .slice(1)
+    .reduce(
+      (total, value, index) =>
+        total + Math.abs(value - normalized[index] - averageStep),
+      0,
+    );
+  return clamp((deviation / (normalized.length - 1)) * 1.4, 0, 1);
+}
+
+function normalizedTrend(
+  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 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);
+    requiredDrift = Math.max(
+      requiredDrift,
+      (shape[index] - shape[length - 1]) / (1 - progress),
+    );
+  }
+
+  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);
+}
+
+/**
+ * Replace numeric chart series with a stable, seeded upward trend while
+ * retaining the query's original range and every non-series field. This is a
+ * presentation-only demo-mode transform: callers keep the real query result
+ * and opt individual line/area renderers into the returned rows.
+ */
+export function createDemoChartTrendRows(
+  rows: Record<string, unknown>[],
+  yKeys: string[],
+  seed: DemoTrendSeed,
+): Record<string, unknown>[] {
+  if (rows.length === 0 || yKeys.length === 0) return rows;
+
+  let output: Record<string, unknown>[] | null = null;
+
+  for (const yKey of yKeys) {
+    const points = rows.flatMap((row, rowIndex) => {
+      const numeric = numericValue(row[yKey]);
+      return numeric === null
+        ? []
+        : [{ rowIndex, numeric, original: row[yKey] }];
+    });
+
+    if (points.length < 2) continue;
+
+    const minimum = Math.min(...points.map((point) => point.numeric));
+    const maximum = Math.max(...points.map((point) => point.numeric));
+    if (minimum === maximum) continue;
+
+    const random = createRandom(`${String(seed)}:${yKey}`);
+    const range = maximum - minimum;
+    const volatilityScore = normalizedVolatility(
+      points.map((point) => point.numeric),
+      minimum,
+      range,
+    );
+    const trend = normalizedTrend(
+      points.map((point) => point.numeric),
+      minimum,
+      range,
+      volatilityScore,
+      random,
+    );
+    const useStringValues = points.every(
+      (point) => typeof point.original === "string",
+    );
+
+    output ??= rows.map((row) => ({ ...row }));
+    points.forEach((point, pointIndex) => {
+      const numeric =
+        pointIndex === 0
+          ? minimum
+          : pointIndex === points.length - 1
+            ? maximum
+            : minimum + trend[pointIndex] * range;
+      output![point.rowIndex][yKey] = useStringValues
+        ? String(numeric)
+        : numeric;
+    });
+  }
+
+  return output ?? rows;
+}

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}