@viccydev/pi-fpa 0.3.1 → 0.3.2

package/extensions/fpa-data/index.ts

@@ -23,16 +23,34 @@ import { CATALOG_CAVEATS, DATASETS, DATASET_IDS } from "./registry.ts";
 import {
 	buildCohortQuery,
 	buildCoverageSql,
+	buildCoverageStatsSql,
 	buildCohortSizeCoverageSql,
+	COVERAGE_TARGETS,
 	MAX_LIMIT,
 	type QuerySpec,
 } from "./sql.ts";
 import { runStructuredQuery } from "./runtime.ts";
-import { runQuery } from "./supabase.ts";
+import { runQuery, type SqlRow } from "./supabase.ts";
 
 const MAX_TOOL_TEXT_CHARS = 100_000;
 const MAX_DISPLAY_ROWS = 200;
 
+/** Full-scan catalog stats get a shorter leash than a real query; they are context, not answers. */
+const CATALOG_STATS_TIMEOUT_MS = 12_000;
+
+/**
+ * Resolve to null when supplementary work fails, so one slow table degrades a field
+ * instead of the whole tool. A caller-initiated abort still propagates.
+ */
+async function bestEffort<T>(work: Promise<T>, signal?: AbortSignal): Promise<T | null> {
+	try {
+		return await work;
+	} catch (error) {
+		if (signal?.aborted) throw error;
+		return null;
+	}
+}
+
 const DatasetIdSchema = StringEnum(DATASET_IDS as [string, ...string[]], {
 	description: "Dataset id from fpa_data_catalog",
 });
@@ -134,9 +152,19 @@ export default function fpaDataExtension(pi: ExtensionAPI): void {
 		),
 		executionMode: "parallel",
 		async execute(_toolCallId, params, signal) {
-			const [coverage, cohortSize, apps] = await Promise.all([
-				runQuery(buildCoverageSql(), { signal }),
-				runQuery(buildCohortSizeCoverageSql(), { signal }),
+			// Date coverage is the part callers must have, and min/max over an indexed date
+			// column is cheap. Run one query per dataset so a single slow table cannot time
+			// out the whole catalog, then gather the scan-bound stats separately.
+			const coverageRows = await Promise.all(
+				COVERAGE_TARGETS.map(async (target) => (await runQuery(buildCoverageSql(target), { signal }))[0] ?? { dataset: target.dataset }),
+			);
+			const [statsRows, cohortSize, apps] = await Promise.all([
+				Promise.all(
+					COVERAGE_TARGETS.map((target) =>
+						bestEffort(runQuery(buildCoverageStatsSql(target), { signal, timeoutMs: CATALOG_STATS_TIMEOUT_MS }), signal),
+					),
+				),
+				bestEffort(runQuery(buildCohortSizeCoverageSql(), { signal, timeoutMs: CATALOG_STATS_TIMEOUT_MS }), signal),
 				params.include_apps
 					? runQuery(
 							"select app_code, string_agg(distinct platform, ',' order by platform) as platforms " +
@@ -146,6 +174,12 @@ export default function fpaDataExtension(pi: ExtensionAPI): void {
 						)
 					: Promise.resolve<SqlRow[]>([]),
 			]);
+			const coverage = coverageRows.map((row, index) => {
+				const stats = statsRows[index]?.[0];
+				return stats
+					? { ...row, ...stats }
+					: { ...row, row_count: null, apps: null, updated_at: null, stats_unavailable: "Row counts timed out; date coverage above is unaffected." };
+			});
 
 			return toolResult(
 				{
@@ -165,7 +199,7 @@ export default function fpaDataExtension(pi: ExtensionAPI): void {
 						notes: d.notes,
 					})),
 					coverage,
-					cohort_size_available: cohortSize[0] ?? null,
+					cohort_size_available: cohortSize?.[0] ?? null,
 					caveats: CATALOG_CAVEATS,
 					...(params.include_apps ? { apps } : {}),
 				},

package/extensions/fpa-data/sql.ts

@@ -442,17 +442,50 @@ export function buildCohortQuery(spec: CohortSpec): BuiltCohortQuery {
 	return { sql, spendSql, asOfSql, horizons, bucket, groupBy };
 }
 
-/** Coverage catalog query used by fpa_data_catalog. */
-export function buildCoverageSql(): string {
-	const parts = [
-		`select 'ua_spend' as dataset, count(*) as row_count, min(install_date)::text as date_min, max(install_date)::text as date_max, count(distinct app_code) as apps, max(updated_at)::text as updated_at from appsflyer_ua_campaign_daily`,
-		`select 'revenue_activity', count(*), min(event_date)::text, max(event_date)::text, count(distinct app_code), max(updated_at)::text from appsflyer_install_cohort_daily`,
-		`select 'cohort (fpa_cohort)', count(*), min(install_date)::text, max(install_date)::text, count(distinct app_code), max(updated_at)::text from appsflyer_install_cohort_daily`,
-		`select 'apple_store', count(*), min(metric_date)::text, max(metric_date)::text, count(distinct adam_id), max(updated_at)::text from apple_app_daily`,
-		`select 'product_events', count(*), min(event_date)::text, max(event_date)::text, count(distinct app_code), max(updated_at)::text from appsflyer_event_daily`,
-		`select 'mixpanel_product', count(*), min(business_date)::text, max(business_date)::text, count(distinct app_code), max(updated_at)::text from mixpanel_app_daily`,
-	];
-	return assertReadOnly(parts.join(" union all "));
+/** One row of the fpa_data_catalog coverage block. */
+export interface CoverageTarget {
+	dataset: string;
+	table: string;
+	dateColumn: string;
+	appColumn: string;
+}
+
+export const COVERAGE_TARGETS: CoverageTarget[] = [
+	{ dataset: "ua_spend", table: "appsflyer_ua_campaign_daily", dateColumn: "install_date", appColumn: "app_code" },
+	{ dataset: "revenue_activity", table: "appsflyer_install_cohort_daily", dateColumn: "event_date", appColumn: "app_code" },
+	{ dataset: "cohort (fpa_cohort)", table: "appsflyer_install_cohort_daily", dateColumn: "install_date", appColumn: "app_code" },
+	{ dataset: "apple_store", table: "apple_app_daily", dateColumn: "metric_date", appColumn: "adam_id" },
+	{ dataset: "product_events", table: "appsflyer_event_daily", dateColumn: "event_date", appColumn: "app_code" },
+	{ dataset: "mixpanel_product", table: "mixpanel_app_daily", dateColumn: "business_date", appColumn: "app_code" },
+];
+
+/**
+ * Answerable date range for one dataset.
+ *
+ * min()/max() alone let Postgres walk the date index instead of scanning the table.
+ * Mixing them with count(*) in a single statement — as the old six-way UNION did —
+ * forces a sequential scan per arm, which is what pushed fpa_data_catalog past its
+ * timeout as the mart grew.
+ */
+export function buildCoverageSql(target: CoverageTarget): string {
+	return assertReadOnly(
+		`select ${escapeLiteral(target.dataset)} as dataset, ` +
+			`min(${target.dateColumn})::text as date_min, max(${target.dateColumn})::text as date_max ` +
+			`from ${target.table}`,
+	);
+}
+
+/**
+ * Row counts and freshness for one dataset. These need a full scan (count(distinct)
+ * most of all), so callers treat them as best-effort and report null when they time out
+ * rather than failing the whole catalog.
+ */
+export function buildCoverageStatsSql(target: CoverageTarget): string {
+	return assertReadOnly(
+		`select count(*) as row_count, count(distinct ${target.appColumn}) as apps, ` +
+			`max(updated_at)::text as updated_at ` +
+			`from ${target.table}`,
+	);
 }
 
 /** Cohort-size availability window, reported by fpa_data_catalog. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@viccydev/pi-fpa",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "type": "module",
   "description": "Full-cycle FP&A planning, strategy, forecast, and review prompts, skills, and data tools for Pi",
   "license": "UNLICENSED",