@contractspec/example.product-intent 1.57.0 → 1.58.0

package/dist/load-evidence.js

@@ -1,75 +1,314 @@
-import { loadPosthogEvidenceChunks } from "./posthog-signals.js";
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
+// @bun
+// src/posthog-signals.ts
+import { FunnelAnalyzer } from "@contractspec/lib.analytics/funnel";
+import { PosthogAnalyticsProvider } from "@contractspec/integration.providers-impls/impls/posthog";
+async function loadPosthogEvidenceChunks(options) {
+  const chunks = [];
+  const range = resolveRange(options.dateRange);
+  const eventSummary = await loadEventSummary(options, range);
+  if (eventSummary) {
+    chunks.push(eventSummary);
+  }
+  const funnelEvidence = await loadFunnelEvidence(options, range);
+  if (funnelEvidence) {
+    chunks.push(funnelEvidence);
+  }
+  const featureFlags = await loadFeatureFlagEvidence(options);
+  if (featureFlags) {
+    chunks.push(featureFlags);
+  }
+  return chunks;
+}
+async function loadEventSummary(options, range) {
+  if (!options.reader.queryHogQL)
+    return null;
+  const eventFilter = buildEventFilter(options.eventNames);
+  const limit = options.limit ?? 10;
+  const result = await options.reader.queryHogQL({
+    query: [
+      "select",
+      "  event as eventName,",
+      "  count() as total",
+      "from events",
+      "where timestamp >= {dateFrom} and timestamp < {dateTo}",
+      eventFilter.clause ? `and ${eventFilter.clause}` : "",
+      "group by eventName",
+      "order by total desc",
+      `limit ${limit}`
+    ].filter(Boolean).join(`
+`),
+    values: {
+      dateFrom: range.from.toISOString(),
+      dateTo: range.to.toISOString(),
+      ...eventFilter.values
+    }
+  });
+  const rows = mapRows(result);
+  if (rows.length === 0)
+    return null;
+  const lines = rows.map((row) => {
+    const name = asString(row.eventName) ?? "unknown";
+    const total = asNumber(row.total);
+    return `- ${name}: ${total}`;
+  });
+  return {
+    chunkId: `posthog:event_summary:${range.from.toISOString()}`,
+    text: [
+      `PostHog event summary (${range.from.toISOString()} \u2192 ${range.to.toISOString()}):`,
+      ...lines
+    ].join(`
+`),
+    meta: {
+      source: "posthog",
+      kind: "event_summary",
+      dateFrom: range.from.toISOString(),
+      dateTo: range.to.toISOString()
+    }
+  };
+}
+async function loadFunnelEvidence(options, range) {
+  if (!options.funnel)
+    return null;
+  if (!options.reader.getEvents)
+    return null;
+  const events = [];
+  const eventNames = options.funnel.steps.map((step) => step.eventName);
+  for (const eventName of eventNames) {
+    const response = await options.reader.getEvents({
+      event: eventName,
+      dateRange: {
+        from: range.from,
+        to: range.to
+      },
+      limit: options.limit ?? 500
+    });
+    response.results.forEach((event) => {
+      events.push({
+        name: event.event,
+        userId: event.distinctId,
+        tenantId: typeof event.properties?.tenantId === "string" ? event.properties.tenantId : undefined,
+        timestamp: event.timestamp,
+        properties: event.properties
+      });
+    });
+  }
+  if (events.length === 0)
+    return null;
+  const analyzer = new FunnelAnalyzer;
+  const analysis = analyzer.analyze(events, options.funnel);
+  const lines = analysis.steps.map((step) => {
+    return `- ${step.step.eventName}: ${step.count} (conversion ${step.conversionRate}, drop-off ${step.dropOffRate})`;
+  });
+  return {
+    chunkId: `posthog:funnel:${options.funnel.name}`,
+    text: [`PostHog funnel analysis \u2014 ${options.funnel.name}:`, ...lines].join(`
+`),
+    meta: {
+      source: "posthog",
+      kind: "funnel",
+      funnelName: options.funnel.name,
+      dateFrom: range.from.toISOString(),
+      dateTo: range.to.toISOString()
+    }
+  };
+}
+async function loadFeatureFlagEvidence(options) {
+  if (!options.includeFeatureFlags)
+    return null;
+  if (!options.reader.getFeatureFlags)
+    return null;
+  const response = await options.reader.getFeatureFlags({ limit: 10 });
+  if (!response.results.length)
+    return null;
+  const lines = response.results.map((flag) => {
+    const key = flag.key ?? "unknown";
+    const active = flag.active ? "active" : "inactive";
+    return `- ${key}: ${active}`;
+  });
+  return {
+    chunkId: "posthog:feature_flags",
+    text: ["PostHog feature flags:", ...lines].join(`
+`),
+    meta: {
+      source: "posthog",
+      kind: "feature_flags"
+    }
+  };
+}
+function resolveRange(dateRange) {
+  const now = new Date;
+  const from = dateRange?.from instanceof Date ? dateRange.from : dateRange?.from ? new Date(dateRange.from) : new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
+  const to = dateRange?.to instanceof Date ? dateRange.to : dateRange?.to ? new Date(dateRange.to) : now;
+  return { from, to };
+}
+function buildEventFilter(eventNames) {
+  if (!eventNames || eventNames.length === 0)
+    return {};
+  if (eventNames.length === 1) {
+    return {
+      clause: "event = {event0}",
+      values: { event0: eventNames[0] }
+    };
+  }
+  const values = {};
+  const clauses = eventNames.map((eventName, index) => {
+    values[`event${index}`] = eventName;
+    return `event = {event${index}}`;
+  });
+  return {
+    clause: `(${clauses.join(" or ")})`,
+    values
+  };
+}
+function mapRows(result) {
+  if (!Array.isArray(result.results) || !Array.isArray(result.columns)) {
+    return [];
+  }
+  const columns = result.columns;
+  return result.results.flatMap((row) => {
+    if (!Array.isArray(row))
+      return [];
+    const record = {};
+    columns.forEach((column, index) => {
+      record[column] = row[index];
+    });
+    return [record];
+  });
+}
+function asString(value) {
+  if (typeof value === "string" && value.trim())
+    return value;
+  if (typeof value === "number")
+    return String(value);
+  return null;
+}
+function asNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return 0;
+}
+function resolvePosthogEvidenceOptionsFromEnv(options = {}) {
+  const projectId = process.env.POSTHOG_PROJECT_ID;
+  const personalApiKey = process.env.POSTHOG_PERSONAL_API_KEY;
+  if (!projectId || !personalApiKey)
+    return null;
+  const lookbackDays = resolveNumberEnv("POSTHOG_EVIDENCE_LOOKBACK_DAYS", options.defaultLookbackDays ?? 30);
+  const limit = resolveNumberEnv("POSTHOG_EVIDENCE_LIMIT", options.defaultLimit ?? 10);
+  const now = new Date;
+  const from = new Date(now.getTime() - lookbackDays * 24 * 60 * 60 * 1000);
+  const eventNames = resolveCsvEnv("POSTHOG_EVIDENCE_EVENTS");
+  const funnelSteps = resolveCsvEnv("POSTHOG_EVIDENCE_FUNNEL_STEPS");
+  const funnel = funnelSteps && funnelSteps.length ? {
+    name: "posthog-evidence-funnel",
+    steps: funnelSteps.map((eventName, index) => ({
+      id: `step_${index + 1}`,
+      eventName
+    }))
+  } : undefined;
+  const reader = new PosthogAnalyticsProvider({
+    host: process.env.POSTHOG_HOST,
+    projectId,
+    personalApiKey
+  });
+  return {
+    reader,
+    dateRange: { from, to: now },
+    eventNames,
+    limit,
+    funnel,
+    includeFeatureFlags: resolveBooleanEnv("POSTHOG_EVIDENCE_FEATURE_FLAGS", true)
+  };
+}
+function resolveCsvEnv(key) {
+  const value = process.env[key];
+  if (!value)
+    return;
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function resolveNumberEnv(key, fallback) {
+  const value = process.env[key];
+  if (!value)
+    return fallback;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function resolveBooleanEnv(key, fallback) {
+  const value = process.env[key];
+  if (value === undefined)
+    return fallback;
+  return value.toLowerCase() === "true";
+}
 
-//#region src/load-evidence.ts
-const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
-const DEFAULT_EVIDENCE_ROOT = path.join(MODULE_DIR, "../evidence");
-const DEFAULT_TRANSCRIPT_DIRS = [
-	"interviews",
-	"tickets",
-	"public"
-];
-const DEFAULT_CHUNK_SIZE = 800;
-/**
-* Remove YAML front matter from a file. Synthetic interview and ticket
-* files include a YAML header delimited by triple dashes.
-*/
+// src/load-evidence.ts
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+var MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+var DEFAULT_EVIDENCE_ROOT = path.join(MODULE_DIR, "../evidence");
+var DEFAULT_TRANSCRIPT_DIRS = ["interviews", "tickets", "public"];
+var DEFAULT_CHUNK_SIZE = 800;
 function stripYamlFrontMatter(contents) {
-	const start = contents.indexOf("---");
-	if (start === -1) return contents;
-	const end = contents.indexOf("---", start + 3);
-	if (end === -1) return contents;
-	return contents.slice(end + 3).trimStart();
-}
-/**
-* Split a transcript into fixed-size chunks.
-*/
+  const start = contents.indexOf("---");
+  if (start === -1)
+    return contents;
+  const end = contents.indexOf("---", start + 3);
+  if (end === -1)
+    return contents;
+  return contents.slice(end + 3).trimStart();
+}
 function chunkTranscript(fileId, text, chunkSize) {
-	const chunks = [];
-	const clean = text.trim();
-	for (let offset = 0, idx = 0; offset < clean.length; idx += 1) {
-		const slice = clean.slice(offset, offset + chunkSize);
-		chunks.push({
-			chunkId: `${fileId}#c_${String(idx).padStart(2, "0")}`,
-			text: slice,
-			meta: { source: fileId }
-		});
-		offset += chunkSize;
-	}
-	return chunks;
-}
-/**
-* Load all transcript files under the given directories and return
-* EvidenceChunk objects ready for prompt formatting.
-*/
+  const chunks = [];
+  const clean = text.trim();
+  for (let offset = 0, idx = 0;offset < clean.length; idx += 1) {
+    const slice = clean.slice(offset, offset + chunkSize);
+    chunks.push({
+      chunkId: `${fileId}#c_${String(idx).padStart(2, "0")}`,
+      text: slice,
+      meta: { source: fileId }
+    });
+    offset += chunkSize;
+  }
+  return chunks;
+}
 function loadEvidenceChunks(options = {}) {
-	const evidenceRoot = options.evidenceRoot ?? DEFAULT_EVIDENCE_ROOT;
-	const transcriptDirs = options.transcriptDirs ?? DEFAULT_TRANSCRIPT_DIRS;
-	const chunkSize = options.chunkSize ?? DEFAULT_CHUNK_SIZE;
-	const chunks = [];
-	for (const dir of transcriptDirs) {
-		const fullDir = path.join(evidenceRoot, dir);
-		if (!fs.existsSync(fullDir)) continue;
-		for (const fileName of fs.readdirSync(fullDir)) {
-			if (path.extname(fileName).toLowerCase() !== ".md") continue;
-			const filePath = path.join(fullDir, fileName);
-			const withoutFrontMatter = stripYamlFrontMatter(fs.readFileSync(filePath, "utf8"));
-			const baseId = path.parse(fileName).name;
-			const fileChunks = chunkTranscript(baseId, withoutFrontMatter, chunkSize);
-			chunks.push(...fileChunks);
-		}
-	}
-	return chunks;
+  const evidenceRoot = options.evidenceRoot ?? DEFAULT_EVIDENCE_ROOT;
+  const transcriptDirs = options.transcriptDirs ?? DEFAULT_TRANSCRIPT_DIRS;
+  const chunkSize = options.chunkSize ?? DEFAULT_CHUNK_SIZE;
+  const chunks = [];
+  for (const dir of transcriptDirs) {
+    const fullDir = path.join(evidenceRoot, dir);
+    if (!fs.existsSync(fullDir))
+      continue;
+    for (const fileName of fs.readdirSync(fullDir)) {
+      const ext = path.extname(fileName).toLowerCase();
+      if (ext !== ".md")
+        continue;
+      const filePath = path.join(fullDir, fileName);
+      const raw = fs.readFileSync(filePath, "utf8");
+      const withoutFrontMatter = stripYamlFrontMatter(raw);
+      const baseId = path.parse(fileName).name;
+      const fileChunks = chunkTranscript(baseId, withoutFrontMatter, chunkSize);
+      chunks.push(...fileChunks);
+    }
+  }
+  return chunks;
 }
 async function loadEvidenceChunksWithSignals(options = {}) {
-	const baseChunks = loadEvidenceChunks(options);
-	if (!options.posthog) return baseChunks;
-	const posthogChunks = await loadPosthogEvidenceChunks(options.posthog);
-	return [...baseChunks, ...posthogChunks];
+  const baseChunks = loadEvidenceChunks(options);
+  if (!options.posthog)
+    return baseChunks;
+  const posthogChunks = await loadPosthogEvidenceChunks(options.posthog);
+  return [...baseChunks, ...posthogChunks];
 }
-
-//#endregion
-export { DEFAULT_CHUNK_SIZE, DEFAULT_EVIDENCE_ROOT, DEFAULT_TRANSCRIPT_DIRS, loadEvidenceChunks, loadEvidenceChunksWithSignals };
-//# sourceMappingURL=load-evidence.js.map
+export {
+  loadEvidenceChunksWithSignals,
+  loadEvidenceChunks,
+  DEFAULT_TRANSCRIPT_DIRS,
+  DEFAULT_EVIDENCE_ROOT,
+  DEFAULT_CHUNK_SIZE
+};

package/dist/load-evidence.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=load-evidence.test.d.ts.map

package/dist/load-evidence.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-evidence.test.d.ts","sourceRoot":"","sources":["../src/load-evidence.test.ts"],"names":[],"mappings":""}

package/dist/node/example.js

@@ -0,0 +1,28 @@
+// src/example.ts
+import { defineExample } from "@contractspec/lib.contracts";
+var example = defineExample({
+  meta: {
+    key: "product-intent",
+    version: "1.0.0",
+    title: "Product Intent Discovery",
+    description: "Evidence ingestion and product-intent workflow for PM discovery.",
+    kind: "script",
+    visibility: "public",
+    stability: "experimental",
+    owners: ["@platform.core"],
+    tags: ["product-intent", "discovery", "pm", "evidence", "llm"]
+  },
+  entrypoints: {
+    packageName: "@contractspec/example.product-intent"
+  },
+  surfaces: {
+    templates: false,
+    sandbox: { enabled: false, modes: [] },
+    studio: { enabled: false, installable: false },
+    mcp: { enabled: false }
+  }
+});
+var example_default = example;
+export {
+  example_default as default
+};