@yourbright/emdash-analytics-plugin 0.1.1

package/src/sync.ts

@@ -0,0 +1,749 @@
+import { generatePrefixedToken, hashPrefixedToken } from "@emdash-cms/auth";
+import type { PluginContext } from "emdash";
+import { PluginRouteError } from "emdash";
+import { ulid } from "ulidx";
+
+import {
+  AGENT_KEY_PREFIX,
+  CRON_ENRICH_MANAGED,
+  CRON_SYNC_BASE,
+  FRESHNESS_KEY,
+  GSC_QUERY_PAGE_LIMIT,
+  GSC_QUERY_ROW_LIMIT,
+  QUERY_REFRESH_STALE_HOURS,
+  SITE_SUMMARY_KEY
+} from "./constants.js";
+import {
+  buildContentUrl,
+  classifyPageKind,
+  dailyMetricStorageId,
+  getManagedContentMap,
+  pageQueryStorageId,
+  pageStorageId
+} from "./content.js";
+import { parseServiceAccount } from "./config-validation.js";
+import { loadConfig } from "./config.js";
+import {
+  buildWindows,
+  fetchGaDailyTrend,
+  fetchGaPageMetrics,
+  fetchGscDailyTrend,
+  fetchGscPageMetrics,
+  fetchGscPageQueries,
+  runConnectionTest
+} from "./google.js";
+import { scorePage } from "./scoring.js";
+import type {
+  AgentKeyRecord,
+  ContentContextResponse,
+  DailyMetricRecord,
+  FreshnessState,
+  ManagedContentRef,
+  PageAggregateRecord,
+  PageListFilters,
+  PageListResponse,
+  PageQueryRecord,
+  PluginConfigSummary,
+  SavedPluginConfig,
+  SiteSummary,
+  SyncRunRecord
+} from "./types.js";
+
+type PluginCtx = PluginContext;
+type CombinedTrendMetric = {
+  date: string;
+  clicks: number;
+  impressions: number;
+  views: number;
+  sessions: number;
+  users: number;
+};
+
+export async function getStatus(ctx: PluginCtx): Promise<{
+  config: PluginConfigSummary | null;
+  summary: SiteSummary | null;
+  freshness: FreshnessState;
+}> {
+  const config = await loadConfig(ctx);
+  return {
+    config: config
+      ? {
+          siteOrigin: config.siteOrigin,
+          ga4PropertyId: config.ga4PropertyId,
+          gscSiteUrl: config.gscSiteUrl,
+          hasServiceAccount: true,
+          serviceAccountEmail: parseServiceAccount(config.serviceAccountJson).client_email
+        }
+      : null,
+    summary: await ctx.kv.get<SiteSummary>(SITE_SUMMARY_KEY),
+    freshness: await getFreshness(ctx)
+  };
+}
+
+export async function testConnection(
+  ctx: PluginCtx,
+  draftConfig?: SavedPluginConfig | null
+): Promise<Record<string, unknown>> {
+  const config = draftConfig ?? (await loadConfig(ctx));
+  if (!config) {
+    throw new PluginRouteError("BAD_REQUEST", "Analytics connection is not configured", 400);
+  }
+  if (!ctx.http) {
+    throw new PluginRouteError("INTERNAL_ERROR", "HTTP capability is unavailable", 500);
+  }
+  return runConnectionTest(ctx.http, config, parseServiceAccount(config.serviceAccountJson));
+}
+
+export async function syncBase(ctx: PluginCtx, jobType: SyncRunRecord["jobType"]): Promise<{
+  trackedPages: number;
+  managedPages: number;
+}> {
+  const config = await requireConfig(ctx);
+  if (!ctx.http) {
+    throw new PluginRouteError("INTERNAL_ERROR", "HTTP capability is unavailable", 500);
+  }
+
+  const serviceAccount = parseServiceAccount(config.serviceAccountJson);
+  const windows = buildWindows();
+  const startedAt = new Date().toISOString();
+  const managedMap = await getManagedContentMap(config.siteOrigin);
+
+  const [gscCurrent, gscPrevious, gscTrend, gaCurrent, gaPrevious, gaTrend] = await Promise.all([
+    fetchGscPageMetrics(ctx.http, config, serviceAccount, windows.gscCurrent),
+    fetchGscPageMetrics(ctx.http, config, serviceAccount, windows.gscPrevious),
+    fetchGscDailyTrend(ctx.http, config, serviceAccount, windows.gscCurrent),
+    fetchGaPageMetrics(ctx.http, config, serviceAccount, windows.gaCurrent),
+    fetchGaPageMetrics(ctx.http, config, serviceAccount, windows.gaPrevious),
+    fetchGaDailyTrend(ctx.http, config, serviceAccount, windows.gaCurrent)
+  ]);
+
+  const host = new URL(config.siteOrigin).hostname;
+  const pages = new Map<string, PageAggregateRecord>();
+  const nowIso = new Date().toISOString();
+
+  const ensurePage = (urlPath: string): PageAggregateRecord => {
+    const existing = pages.get(urlPath);
+    if (existing) return existing;
+
+    const managed = managedMap.get(urlPath) ?? null;
+    const created: PageAggregateRecord = {
+      urlPath,
+      host,
+      pageKind: classifyPageKind(urlPath),
+      managed: !!managed,
+      title: managed?.title || urlPath,
+      contentCollection: managed?.collection || null,
+      contentId: managed?.id || null,
+      contentSlug: managed?.slug || null,
+      gscClicks28d: 0,
+      gscImpressions28d: 0,
+      gscCtr28d: 0,
+      gscPosition28d: 0,
+      gscClicksPrev28d: 0,
+      gscImpressionsPrev28d: 0,
+      gaViews28d: 0,
+      gaUsers28d: 0,
+      gaSessions28d: 0,
+      gaEngagementRate28d: 0,
+      gaBounceRate28d: 0,
+      gaAvgSessionDuration28d: 0,
+      gaViewsPrev28d: 0,
+      gaUsersPrev28d: 0,
+      gaSessionsPrev28d: 0,
+      opportunityScore: 0,
+      opportunityTags: [],
+      lastSyncedAt: nowIso,
+      lastGscDate: windows.gscCurrent.endDate,
+      lastGaDate: windows.gaCurrent.endDate
+    };
+    pages.set(urlPath, created);
+    return created;
+  };
+
+  for (const metric of gscCurrent) {
+    const page = ensurePage(metric.urlPath);
+    page.gscClicks28d = metric.clicks;
+    page.gscImpressions28d = metric.impressions;
+    page.gscCtr28d = metric.ctr;
+    page.gscPosition28d = metric.position;
+  }
+  for (const metric of gscPrevious) {
+    const page = ensurePage(metric.urlPath);
+    page.gscClicksPrev28d = metric.clicks;
+    page.gscImpressionsPrev28d = metric.impressions;
+  }
+  for (const metric of gaCurrent) {
+    const page = ensurePage(metric.urlPath);
+    page.gaViews28d = metric.views;
+    page.gaUsers28d = metric.users;
+    page.gaSessions28d = metric.sessions;
+    page.gaEngagementRate28d = metric.engagementRate;
+    page.gaBounceRate28d = metric.bounceRate;
+    page.gaAvgSessionDuration28d = metric.averageSessionDuration;
+  }
+  for (const metric of gaPrevious) {
+    const page = ensurePage(metric.urlPath);
+    page.gaViewsPrev28d = metric.views;
+    page.gaUsersPrev28d = metric.users;
+    page.gaSessionsPrev28d = metric.sessions;
+  }
+
+  for (const page of pages.values()) {
+    const score = scorePage(page, []);
+    page.opportunityScore = score.score;
+    page.opportunityTags = score.tags;
+  }
+
+  await ctx.storage.pages.putMany(
+    Array.from(pages.values()).map((page) => ({
+      id: pageStorageId(page.urlPath),
+      data: page
+    }))
+  );
+
+  const combinedTrend = mergeTrend(gscTrend, gaTrend);
+  await ctx.storage.daily_metrics.putMany(
+    combinedTrend.flatMap((row) => [
+      {
+        id: dailyMetricStorageId("gsc", "all_public", row.date),
+        data: {
+          source: "gsc",
+          scope: "all_public",
+          date: row.date,
+          clicks: row.clicks,
+          impressions: row.impressions,
+          views: 0,
+          sessions: 0,
+          users: 0
+        } satisfies DailyMetricRecord
+      },
+      {
+        id: dailyMetricStorageId("ga", "all_public", row.date),
+        data: {
+          source: "ga",
+          scope: "all_public",
+          date: row.date,
+          clicks: 0,
+          impressions: 0,
+          views: row.views,
+          sessions: row.sessions,
+          users: row.users
+        } satisfies DailyMetricRecord
+      }
+    ])
+  );
+
+  const freshness: FreshnessState = {
+    lastSyncedAt: nowIso,
+    lastGscDate: windows.gscCurrent.endDate,
+    lastGaDate: windows.gaCurrent.endDate,
+    lastStatus: "success"
+  };
+  const summary = buildSummary(Array.from(pages.values()), combinedTrend, windows);
+  await Promise.all([
+    ctx.kv.set(FRESHNESS_KEY, freshness),
+    ctx.kv.set(SITE_SUMMARY_KEY, summary),
+    writeSyncRun(ctx, {
+      jobType,
+      status: "success",
+      startedAt,
+      finishedAt: nowIso,
+      summary: {
+        trackedPages: pages.size,
+        managedPages: Array.from(pages.values()).filter((page) => page.managed).length
+      },
+      error: null
+    })
+  ]);
+
+  return {
+    trackedPages: pages.size,
+    managedPages: Array.from(pages.values()).filter((page) => page.managed).length
+  };
+}
+
+export async function enrichManagedQueries(ctx: PluginCtx): Promise<{ refreshedPages: number }> {
+  const config = await requireConfig(ctx);
+  if (!ctx.http) {
+    throw new PluginRouteError("INTERNAL_ERROR", "HTTP capability is unavailable", 500);
+  }
+  const serviceAccount = parseServiceAccount(config.serviceAccountJson);
+  const windows = buildWindows();
+
+  const candidateResult = await ctx.storage.pages.query({
+    where: {
+      managed: true,
+      opportunityScore: { gt: 0 }
+    },
+    orderBy: { opportunityScore: "desc" },
+    limit: GSC_QUERY_PAGE_LIMIT
+  });
+
+  let refreshedPages = 0;
+  for (const item of candidateResult.items) {
+    const page = item.data as PageAggregateRecord;
+    const queries = await fetchGscPageQueries(
+      ctx.http,
+      config,
+      serviceAccount,
+      page.urlPath,
+      windows.gscCurrent,
+      GSC_QUERY_ROW_LIMIT
+    );
+    const existing = await ctx.storage.page_queries.query({
+      where: { urlPath: page.urlPath },
+      limit: 100
+    });
+    if (existing.items.length > 0) {
+      await ctx.storage.page_queries.deleteMany(existing.items.map((entry) => entry.id));
+    }
+    if (queries.length > 0) {
+      await ctx.storage.page_queries.putMany(
+        queries.map((query) => ({
+          id: pageQueryStorageId(page.urlPath, query.query),
+          data: {
+            urlPath: page.urlPath,
+            query: query.query,
+            clicks28d: query.clicks,
+            impressions28d: query.impressions,
+            ctr28d: query.ctr,
+            position28d: query.position,
+            updatedAt: new Date().toISOString()
+          } satisfies PageQueryRecord
+        }))
+      );
+    }
+
+    const queryRows = await getPageQueries(ctx, page.urlPath);
+    const rescored = scorePage(page, queryRows);
+    page.opportunityScore = rescored.score;
+    page.opportunityTags = rescored.tags;
+    page.lastSyncedAt = new Date().toISOString();
+    await ctx.storage.pages.put(pageStorageId(page.urlPath), page);
+    refreshedPages += 1;
+  }
+
+  await refreshSummaryFromStorage(ctx);
+  await writeSyncRun(ctx, {
+    jobType: CRON_ENRICH_MANAGED,
+    status: "success",
+    startedAt: new Date().toISOString(),
+    finishedAt: new Date().toISOString(),
+    summary: { refreshedPages },
+    error: null
+  });
+
+  return { refreshedPages };
+}
+
+export async function listPages(ctx: PluginCtx, filters: PageListFilters): Promise<PageListResponse> {
+  const where: Record<string, any> = {};
+  if (filters.managed === "managed") where.managed = true;
+  if (filters.managed === "unmanaged") where.managed = false;
+  if (filters.pageKind && filters.pageKind !== "all") where.pageKind = filters.pageKind;
+  if (filters.hasOpportunity) where.opportunityScore = { gt: 0 };
+
+  const result = await ctx.storage.pages.query({
+    where,
+    orderBy: { opportunityScore: "desc" },
+    limit: filters.limit ?? 50,
+    cursor: filters.cursor
+  });
+
+  return {
+    items: result.items.map((item) => item.data as PageAggregateRecord),
+    cursor: result.cursor,
+    hasMore: result.hasMore
+  };
+}
+
+export async function getOverview(ctx: PluginCtx): Promise<{
+  summary: SiteSummary | null;
+  freshness: FreshnessState;
+  topOpportunities: PageAggregateRecord[];
+  topUnmanaged: PageAggregateRecord[];
+}> {
+  const [summary, freshness, topOpportunities, topUnmanaged] = await Promise.all([
+    ctx.kv.get<SiteSummary>(SITE_SUMMARY_KEY),
+    getFreshness(ctx),
+    ctx.storage.pages.query({
+      where: { managed: true, opportunityScore: { gt: 0 } },
+      orderBy: { opportunityScore: "desc" },
+      limit: 5
+    }),
+    ctx.storage.pages.query({
+      where: { managed: false },
+      orderBy: { gaViews28d: "desc" },
+      limit: 5
+    })
+  ]);
+
+  return {
+    summary,
+    freshness,
+    topOpportunities: topOpportunities.items.map((item) => item.data as PageAggregateRecord),
+    topUnmanaged: topUnmanaged.items.map((item) => item.data as PageAggregateRecord)
+  };
+}
+
+export async function getContentContext(
+  ctx: PluginCtx,
+  collection: string,
+  id?: string,
+  slug?: string
+): Promise<ContentContextResponse> {
+  const config = await requireConfig(ctx);
+  const managedMap = await getManagedContentMap(config.siteOrigin);
+  let contentRef: ManagedContentRef | null = null;
+
+  if (id) {
+    contentRef =
+      Array.from(managedMap.values()).find(
+        (entry) => entry.collection === collection && entry.id === id
+      ) || null;
+  }
+  if (!contentRef && slug) {
+    contentRef =
+      Array.from(managedMap.values()).find(
+        (entry) => entry.collection === collection && entry.slug === slug
+      ) || null;
+  }
+  if (!contentRef) {
+    throw new PluginRouteError("NOT_FOUND", "Managed content not found", 404);
+  }
+
+  const page = await loadPage(ctx, contentRef.urlPath);
+  if (!page) {
+    throw new PluginRouteError("NOT_FOUND", "Analytics data not found for content", 404);
+  }
+
+  const queries = await getFreshQueriesForPage(ctx, config, contentRef.urlPath);
+  const windows = buildWindows();
+  const score = scorePage(page, queries);
+  const freshness = await getFreshness(ctx);
+
+  return {
+    content: {
+      collection: "posts",
+      id: contentRef.id,
+      slug: contentRef.slug,
+      title: contentRef.title,
+      urlPath: contentRef.urlPath,
+      url: buildContentUrl(config.siteOrigin, contentRef.urlPath),
+      excerpt: contentRef.excerpt ?? null,
+      seoDescription: contentRef.seoDescription ?? null
+    },
+    analytics: {
+      window: windows,
+      page: {
+        ...page,
+        gscClicksDelta: page.gscClicks28d - page.gscClicksPrev28d,
+        gscImpressionsDelta: page.gscImpressions28d - page.gscImpressionsPrev28d,
+        gaViewsDelta: page.gaViews28d - page.gaViewsPrev28d,
+        gaUsersDelta: page.gaUsers28d - page.gaUsersPrev28d,
+        gaSessionsDelta: page.gaSessions28d - page.gaSessionsPrev28d
+      },
+      searchQueries: queries,
+      opportunities: score.evidence,
+      freshness
+    }
+  };
+}
+
+export async function listAgentKeys(ctx: PluginCtx): Promise<Array<Omit<AgentKeyRecord, "hash">>> {
+  const result = await ctx.storage.agent_keys.query({
+    orderBy: { createdAt: "desc" },
+    limit: 100
+  });
+  return result.items.map((item) => {
+    const record = item.data as AgentKeyRecord;
+    return {
+      prefix: record.prefix,
+      label: record.label,
+      createdAt: record.createdAt,
+      lastUsedAt: record.lastUsedAt,
+      revokedAt: record.revokedAt
+    };
+  });
+}
+
+export async function createAgentKey(ctx: PluginCtx, label: string): Promise<{
+  key: string;
+  metadata: Omit<AgentKeyRecord, "hash">;
+}> {
+  const created = generatePrefixedToken(AGENT_KEY_PREFIX);
+  const key = created.raw;
+  const hash = hashPrefixedToken(key);
+  const now = new Date().toISOString();
+
+  const record: AgentKeyRecord = {
+    prefix: created.prefix,
+    hash,
+    label,
+    createdAt: now,
+    lastUsedAt: null,
+    revokedAt: null
+  };
+  await ctx.storage.agent_keys.put(hash, record);
+
+  return {
+    key,
+    metadata: {
+      prefix: record.prefix,
+      label: record.label,
+      createdAt: record.createdAt,
+      lastUsedAt: null,
+      revokedAt: null
+    }
+  };
+}
+
+export async function revokeAgentKey(ctx: PluginCtx, prefix: string): Promise<void> {
+  const result = await ctx.storage.agent_keys.query({
+    where: { prefix },
+    limit: 1
+  });
+  const item = result.items[0];
+  if (!item) {
+    throw new PluginRouteError("NOT_FOUND", "Agent key not found", 404);
+  }
+  const record = item.data as AgentKeyRecord;
+  record.revokedAt = new Date().toISOString();
+  await ctx.storage.agent_keys.put(item.id, record);
+}
+
+export async function authenticateAgentRequest(ctx: PluginCtx, request: Request): Promise<void> {
+  const token = extractAgentToken(request);
+  if (!token.startsWith(AGENT_KEY_PREFIX)) {
+    throw new PluginRouteError("UNAUTHORIZED", "Missing or invalid agent key", 401);
+  }
+
+  const hash = hashPrefixedToken(token);
+  const record = await ctx.storage.agent_keys.get(hash);
+  const keyRecord = record as AgentKeyRecord | null;
+  if (!keyRecord || keyRecord.revokedAt) {
+    throw new PluginRouteError("UNAUTHORIZED", "Missing or invalid agent key", 401);
+  }
+
+  keyRecord.lastUsedAt = new Date().toISOString();
+  await ctx.storage.agent_keys.put(hash, keyRecord);
+}
+
+export function extractAgentToken(request: Request): string {
+  const authHeader = request.headers.get("Authorization") || "";
+  if (authHeader.startsWith("AgentKey ")) {
+    return authHeader.slice("AgentKey ".length).trim();
+  }
+
+  const headerToken = request.headers.get("X-Emdash-Agent-Key") || "";
+  if (headerToken.trim()) {
+    return headerToken.trim();
+  }
+
+  return "";
+}
+
+export async function handleCron(ctx: PluginCtx, eventName: string): Promise<void> {
+  if (eventName === CRON_SYNC_BASE) {
+    await syncBase(ctx, CRON_SYNC_BASE);
+    return;
+  }
+  if (eventName === CRON_ENRICH_MANAGED) {
+    await enrichManagedQueries(ctx);
+  }
+}
+
+async function requireConfig(ctx: PluginCtx): Promise<SavedPluginConfig> {
+  const config = await loadConfig(ctx);
+  if (!config) {
+    throw new PluginRouteError("BAD_REQUEST", "Analytics connection is not configured", 400);
+  }
+  return config;
+}
+
+async function loadPage(ctx: PluginCtx, urlPath: string): Promise<PageAggregateRecord | null> {
+  const page = await ctx.storage.pages.get(pageStorageId(urlPath));
+  return (page as PageAggregateRecord | null) ?? null;
+}
+
+async function getFreshQueriesForPage(
+  ctx: PluginCtx,
+  config: SavedPluginConfig,
+  urlPath: string
+): Promise<PageQueryRecord[]> {
+  let queries = await getPageQueries(ctx, urlPath);
+  const updatedAt = queries[0]?.updatedAt ? Date.parse(queries[0].updatedAt) : 0;
+  const isStale = !updatedAt || Date.now() - updatedAt > QUERY_REFRESH_STALE_HOURS * 60 * 60 * 1000;
+  if (!isStale || !ctx.http) return queries;
+
+  const serviceAccount = parseServiceAccount(config.serviceAccountJson);
+  const windows = buildWindows();
+  const refreshed = await fetchGscPageQueries(
+    ctx.http,
+    config,
+    serviceAccount,
+    urlPath,
+    windows.gscCurrent,
+    GSC_QUERY_ROW_LIMIT
+  );
+  const existing = await ctx.storage.page_queries.query({
+    where: { urlPath },
+    limit: 100
+  });
+  if (existing.items.length > 0) {
+    await ctx.storage.page_queries.deleteMany(existing.items.map((entry) => entry.id));
+  }
+  if (refreshed.length > 0) {
+    const nowIso = new Date().toISOString();
+    await ctx.storage.page_queries.putMany(
+      refreshed.map((query) => ({
+        id: pageQueryStorageId(urlPath, query.query),
+        data: {
+          urlPath,
+          query: query.query,
+          clicks28d: query.clicks,
+          impressions28d: query.impressions,
+          ctr28d: query.ctr,
+          position28d: query.position,
+          updatedAt: nowIso
+        } satisfies PageQueryRecord
+      }))
+    );
+  }
+  queries = await getPageQueries(ctx, urlPath);
+  const page = await loadPage(ctx, urlPath);
+  if (page) {
+    const rescored = scorePage(page, queries);
+    page.opportunityScore = rescored.score;
+    page.opportunityTags = rescored.tags;
+    page.lastSyncedAt = new Date().toISOString();
+    await ctx.storage.pages.put(pageStorageId(urlPath), page);
+  }
+  return queries;
+}
+
+async function getPageQueries(ctx: PluginCtx, urlPath: string): Promise<PageQueryRecord[]> {
+  const result = await ctx.storage.page_queries.query({
+    where: { urlPath },
+    orderBy: { impressions28d: "desc" },
+    limit: 50
+  });
+  return result.items.map((item) => item.data as PageQueryRecord);
+}
+
+async function getFreshness(ctx: PluginCtx): Promise<FreshnessState> {
+  return (
+    (await ctx.kv.get<FreshnessState>(FRESHNESS_KEY)) || {
+      lastSyncedAt: null,
+      lastGscDate: null,
+      lastGaDate: null,
+      lastStatus: "idle"
+    }
+  );
+}
+
+async function refreshSummaryFromStorage(ctx: PluginCtx): Promise<void> {
+  const windows = buildWindows();
+  const allPages: PageAggregateRecord[] = [];
+  let cursor: string | undefined;
+
+  do {
+    const pageBatch = await ctx.storage.pages.query({
+      limit: 500,
+      cursor
+    });
+    cursor = pageBatch.cursor;
+    allPages.push(...pageBatch.items.map((item) => item.data as PageAggregateRecord));
+  } while (cursor);
+
+  const trendMap = new Map<string, { date: string; clicks: number; impressions: number; views: number; sessions: number; users: number }>();
+  let dailyCursor: string | undefined;
+  do {
+    const batch = await ctx.storage.daily_metrics.query({
+      limit: 1000,
+      cursor: dailyCursor
+    });
+    dailyCursor = batch.cursor;
+    for (const item of batch.items) {
+      const row = item.data as DailyMetricRecord;
+      let existing = trendMap.get(row.date);
+      if (!existing) {
+        existing = { date: row.date, clicks: 0, impressions: 0, views: 0, sessions: 0, users: 0 };
+        trendMap.set(row.date, existing);
+      }
+      existing.clicks += row.clicks;
+      existing.impressions += row.impressions;
+      existing.views += row.views;
+      existing.sessions += row.sessions;
+      existing.users += row.users;
+    }
+  } while (dailyCursor);
+
+  await ctx.kv.set(
+    SITE_SUMMARY_KEY,
+    buildSummary(allPages, Array.from(trendMap.values()).sort((a, b) => a.date.localeCompare(b.date)), windows)
+  );
+}
+
+async function writeSyncRun(ctx: PluginCtx, record: SyncRunRecord): Promise<void> {
+  await ctx.storage.sync_runs.put(ulid(), record);
+}
+
+function buildSummary(
+  pages: PageAggregateRecord[],
+  trend: CombinedTrendMetric[],
+  windows: SiteSummary["window"]
+): SiteSummary {
+  return {
+    window: windows,
+    totals: {
+      gscClicks28d: pages.reduce((total, page) => total + page.gscClicks28d, 0),
+      gscImpressions28d: pages.reduce((total, page) => total + page.gscImpressions28d, 0),
+      gaViews28d: pages.reduce((total, page) => total + page.gaViews28d, 0),
+      gaUsers28d: pages.reduce((total, page) => total + page.gaUsers28d, 0),
+      gaSessions28d: pages.reduce((total, page) => total + page.gaSessions28d, 0),
+      managedOpportunities: pages.filter((page) => page.managed && page.opportunityScore > 0).length,
+      trackedPages: pages.length
+    },
+    trend: trend.map((row) => ({
+      date: row.date,
+      gscClicks: row.clicks,
+      gscImpressions: row.impressions,
+      gaViews: row.views,
+      gaSessions: row.sessions,
+      gaUsers: row.users
+    }))
+  };
+}
+
+function mergeTrend(
+  gscTrend: Array<{ date: string; clicks: number; impressions: number }>,
+  gaTrend: Array<{ date: string; views: number; sessions: number; users: number }>
+): CombinedTrendMetric[] {
+  const map = new Map<string, CombinedTrendMetric>();
+  for (const row of gscTrend) {
+    map.set(row.date, {
+      date: row.date,
+      clicks: row.clicks,
+      impressions: row.impressions,
+      views: 0,
+      sessions: 0,
+      users: 0
+    });
+  }
+  for (const row of gaTrend) {
+    const existing = map.get(row.date) || {
+      date: row.date,
+      clicks: 0,
+      impressions: 0,
+      views: 0,
+      sessions: 0,
+      users: 0
+    };
+    existing.views = row.views;
+    existing.sessions = row.sessions;
+    existing.users = row.users;
+    map.set(row.date, existing);
+  }
+  return Array.from(map.values()).sort((left, right) => left.date.localeCompare(right.date));
+}