@gonzih/meet-the-one-ai 1.0.0

package/src/jobs/run-matching.ts

@@ -0,0 +1,243 @@
+import { inngest } from "../lib/inngest.js";
+import { supabase } from "../lib/supabase.js";
+import { complete, extract_json } from "../lib/anthropic.js";
+import { SYSTEM_MATCH_VALIDATION } from "../lib/prompts.js";
+import type { ModalityWeights, Modality } from "../types/index.js";
+
+const WORLD_VIEW_DELTA_MAX = 0.5;
+const CONFIDENCE_THRESHOLD = 0.70;
+const MAX_MATCHES_IN_QUEUE = 10;
+const VECTOR_CANDIDATES_PER_MODALITY = 30;
+
+// Triggered when a user's identity is updated
+// 1. Vector search per active modality via pgvector RPC
+// 2. Hard-filter on worldview bifurcations
+// 3. LLM-validate each candidate
+// 4. Insert confirmed matches + fire match/confirmed
+export const run_matching = inngest.createFunction(
+  { id: "run-matching", retries: 2 },
+  { event: "identity/updated" },
+  async ({ event, step }) => {
+    const { user_id } = event.data;
+
+    // ── Load identity ─────────────────────────────────────────────────────────
+    const identity = await step.run("load-identity", async () => {
+      const { data, error } = await supabase
+        .from("identities")
+        .select("base_profile, modality_weights, signal_completeness_score, ready_for_matching")
+        .eq("user_id", user_id)
+        .single();
+      if (error || !data) throw new Error("Identity not found");
+      return data;
+    });
+
+    if (!identity.ready_for_matching) {
+      return { skipped: true, reason: "not ready for matching" };
+    }
+
+    // ── Check queue capacity ──────────────────────────────────────────────────
+    const { count: pending_count } = await supabase
+      .from("matches")
+      .select("*", { count: "exact", head: true })
+      .or(`user_a_id.eq.${user_id},user_b_id.eq.${user_id}`)
+      .eq("status", "pending_consent");
+
+    if ((pending_count ?? 0) >= MAX_MATCHES_IN_QUEUE) {
+      return { skipped: true, reason: "match queue full" };
+    }
+
+    const slots_available = MAX_MATCHES_IN_QUEUE - (pending_count ?? 0);
+
+    // ── Load user's modality embeddings ───────────────────────────────────────
+    const my_embeddings = await step.run("load-embeddings", async () => {
+      const { data } = await supabase
+        .from("identity_modality_embeddings")
+        .select("modality, embedding")
+        .eq("user_id", user_id);
+      return data ?? [];
+    });
+
+    if (my_embeddings.length === 0) {
+      return { skipped: true, reason: "no embeddings yet" };
+    }
+
+    // ── Build exclusion set (existing matches + declined pairs) ───────────────
+    const [existing_matches, declined_pairs] = await Promise.all([
+      supabase
+        .from("matches")
+        .select("user_a_id, user_b_id")
+        .or(`user_a_id.eq.${user_id},user_b_id.eq.${user_id}`),
+      supabase
+        .from("declined_pairs")
+        .select("user_a_id, user_b_id")
+        .or(`user_a_id.eq.${user_id},user_b_id.eq.${user_id}`),
+    ]);
+
+    const excluded_ids = new Set<string>([user_id]); // always exclude self
+    for (const p of existing_matches.data ?? []) {
+      excluded_ids.add(p.user_a_id);
+      excluded_ids.add(p.user_b_id);
+    }
+    for (const p of declined_pairs.data ?? []) {
+      excluded_ids.add(p.user_a_id);
+      excluded_ids.add(p.user_b_id);
+    }
+
+    // ── Vector search per active modality ─────────────────────────────────────
+    // Best similarity per candidate across all modality searches
+    const candidate_scores = new Map<string, { similarity: number; modality: string }>();
+
+    const vector_results = await step.run("vector-search", async () => {
+      const results: Array<{ user_id: string; modality: string; similarity: number }> = [];
+
+      for (const { modality, embedding } of my_embeddings) {
+        const { data, error } = await supabase.rpc("match_identities", {
+          p_user_id: user_id,
+          p_modality: modality,
+          p_embedding: embedding,
+          p_limit: VECTOR_CANDIDATES_PER_MODALITY,
+        });
+        if (error) {
+          console.error(`match_identities RPC error for modality ${modality}:`, error);
+          continue;
+        }
+        for (const row of data ?? []) {
+          results.push(row);
+        }
+      }
+      return results;
+    });
+
+    for (const row of vector_results) {
+      if (excluded_ids.has(row.user_id)) continue;
+      const existing = candidate_scores.get(row.user_id);
+      if (!existing || row.similarity > existing.similarity) {
+        candidate_scores.set(row.user_id, {
+          similarity: row.similarity,
+          modality: row.modality,
+        });
+      }
+    }
+
+    // Sort by similarity descending, take top 20 for LLM validation
+    const ranked_candidates = Array.from(candidate_scores.entries())
+      .sort((a, b) => b[1].similarity - a[1].similarity)
+      .slice(0, 20)
+      .map(([cid, meta]) => ({ user_id: cid, ...meta }));
+
+    if (ranked_candidates.length === 0) {
+      return { user_id, confirmed_matches: 0, reason: "no vector candidates" };
+    }
+
+    // ── Load candidate full profiles ──────────────────────────────────────────
+    const candidate_ids = ranked_candidates.map((c) => c.user_id);
+    const { data: candidate_profiles } = await supabase
+      .from("identities")
+      .select("user_id, base_profile, modality_weights")
+      .in("user_id", candidate_ids);
+
+    const profile_map = new Map(
+      (candidate_profiles ?? []).map((p) => [p.user_id, p])
+    );
+
+    // ── Hard filter: worldview bifurcation gates ──────────────────────────────
+    const a_wv = identity.base_profile.worldview;
+
+    const passing_candidates = ranked_candidates.filter((c) => {
+      const profile = profile_map.get(c.user_id);
+      if (!profile) return false;
+      const b_wv = profile.base_profile.worldview;
+      const danger_delta = Math.abs(a_wv.world_danger_adventure - b_wv.world_danger_adventure);
+      const people_delta = Math.abs(a_wv.people_good_bad - b_wv.people_good_bad);
+      return danger_delta <= WORLD_VIEW_DELTA_MAX && people_delta <= WORLD_VIEW_DELTA_MAX;
+    });
+
+    // ── LLM validation ────────────────────────────────────────────────────────
+    const confirmed_matches: string[] = [];
+
+    for (const candidate of passing_candidates) {
+      if (confirmed_matches.length >= slots_available) break;
+
+      const profile = profile_map.get(candidate.user_id)!;
+      const primary_modality = dominant_shared_modality(
+        identity.modality_weights,
+        profile.modality_weights
+      );
+
+      const assessment_raw = await step.run(
+        `validate-${candidate.user_id}`,
+        async () =>
+          complete(
+            "matching",
+            SYSTEM_MATCH_VALIDATION,
+            [
+              `Person A profile (${primary_modality} lens):\n${JSON.stringify(identity.base_profile, null, 2)}`,
+              `Person A modality weights: ${JSON.stringify(identity.modality_weights)}`,
+              `\nPerson B profile (${primary_modality} lens):\n${JSON.stringify(profile.base_profile, null, 2)}`,
+              `Person B modality weights: ${JSON.stringify(profile.modality_weights)}`,
+              `\nVector similarity score: ${candidate.similarity.toFixed(3)} (modality: ${candidate.modality})`,
+            ].join("\n\n")
+          )
+      );
+
+      let assessment: Record<string, unknown>;
+      try {
+        assessment = JSON.parse(extract_json(assessment_raw));
+      } catch {
+        console.error(`Failed to parse assessment for ${candidate.user_id}`);
+        continue;
+      }
+
+      if (!assessment.compatible || assessment.tension_fatal) continue;
+      if ((assessment.confidence as number) < CONFIDENCE_THRESHOLD) continue;
+
+      // Insert match and capture the generated UUID
+      const { data: match_row, error: insert_error } = await supabase
+        .from("matches")
+        .insert({
+          user_a_id: user_id,
+          user_b_id: candidate.user_id,
+          primary_modality,
+          cross_modality: assessment.cross_modality ?? false,
+          cross_modality_bridge: assessment.cross_modality_bridge ?? null,
+          confidence_score: assessment.confidence,
+          resonances: assessment.resonances ?? [],
+          tensions: assessment.tensions ?? [],
+          tension_fatal: false,
+          consent_call_framing: assessment.consent_call_framing ?? "",
+          status: "pending_consent",
+          created_at: new Date().toISOString(),
+        })
+        .select("id")
+        .single();
+
+      if (insert_error || !match_row) {
+        console.error("Failed to insert match:", insert_error);
+        continue;
+      }
+
+      confirmed_matches.push(candidate.user_id);
+
+      await step.sendEvent(`match-confirmed-${match_row.id}`, {
+        name: "match/confirmed",
+        data: { match_id: match_row.id },
+      });
+    }
+
+    return { user_id, confirmed_matches: confirmed_matches.length };
+  }
+);
+
+function dominant_shared_modality(a: ModalityWeights, b: ModalityWeights): Modality {
+  const modalities = Object.keys(a) as Modality[];
+  let best = modalities[0];
+  let best_score = 0;
+  for (const m of modalities) {
+    const score = Math.min(a[m], b[m]);
+    if (score > best_score) {
+      best_score = score;
+      best = m;
+    }
+  }
+  return best;
+}

package/src/jobs/scheduled-matching.ts

@@ -0,0 +1,59 @@
+import { inngest } from "../lib/inngest.js";
+import { supabase } from "../lib/supabase.js";
+
+const MAX_MATCHES_IN_QUEUE = 10;
+
+// Hourly cron — finds all ready users with queue capacity and re-runs matching
+// Ensures new users get found by existing users even without a new session
+export const scheduled_matching = inngest.createFunction(
+  { id: "scheduled-matching", retries: 1 },
+  { cron: "0 * * * *" }, // every hour on the hour
+  async ({ step }) => {
+    // Find all users ready for matching
+    const eligible_users = await step.run("find-eligible-users", async () => {
+      const { data, error } = await supabase
+        .from("identities")
+        .select("user_id")
+        .eq("ready_for_matching", true);
+      if (error) throw new Error(`Failed to load eligible users: ${error.message}`);
+      return data ?? [];
+    });
+
+    if (eligible_users.length === 0) {
+      return { triggered: 0 };
+    }
+
+    // Filter to those with queue capacity
+    const user_ids = eligible_users.map((u) => u.user_id);
+
+    const { data: queue_counts } = await supabase
+      .from("matches")
+      .select("user_a_id, user_b_id")
+      .or(user_ids.map((id) => `user_a_id.eq.${id},user_b_id.eq.${id}`).join(","))
+      .eq("status", "pending_consent");
+
+    // Count pending matches per user
+    const pending_per_user = new Map<string, number>();
+    for (const row of queue_counts ?? []) {
+      pending_per_user.set(row.user_a_id, (pending_per_user.get(row.user_a_id) ?? 0) + 1);
+      pending_per_user.set(row.user_b_id, (pending_per_user.get(row.user_b_id) ?? 0) + 1);
+    }
+
+    const users_with_capacity = user_ids.filter(
+      (id) => (pending_per_user.get(id) ?? 0) < MAX_MATCHES_IN_QUEUE
+    );
+
+    // Fan out identity/updated events — run_matching handles each
+    if (users_with_capacity.length > 0) {
+      await step.sendEvent(
+        "scheduled-matching-fanout",
+        users_with_capacity.map((user_id) => ({
+          name: "identity/updated" as const,
+          data: { user_id },
+        }))
+      );
+    }
+
+    return { triggered: users_with_capacity.length, total_eligible: eligible_users.length };
+  }
+);

package/src/jobs/transcribe-session.ts

@@ -0,0 +1,77 @@
+import { inngest } from "../lib/inngest.js";
+import { supabase } from "../lib/supabase.js";
+import { transcribe_url, user_speech_only } from "../lib/deepgram.js";
+import { generate_presigned_get_url, upload_json } from "../lib/r2.js";
+
+// Triggered when a voice session recording lands in R2
+// Runs transcription, stores result, fires next event
+export const transcribe_session = inngest.createFunction(
+  { id: "transcribe-session", retries: 3 },
+  { event: "session/completed" },
+  async ({ event, step }) => {
+    const { user_id, session_id } = event.data;
+
+    // Mark as processing
+    await step.run("mark-processing", async () => {
+      await supabase
+        .from("sessions")
+        .update({ analysis_status: "processing" })
+        .eq("id", session_id);
+    });
+
+    // Get session record to find audio key
+    const session = await step.run("get-session", async () => {
+      const { data, error } = await supabase
+        .from("sessions")
+        .select("audio_r2_key")
+        .eq("id", session_id)
+        .single();
+      if (error || !data) throw new Error(`Session not found: ${session_id}`);
+      if (!data.audio_r2_key) throw new Error(`No audio_r2_key for session: ${session_id}`);
+      return data;
+    });
+
+    // Generate presigned URL for Deepgram to fetch audio from R2
+    const audio_url = await step.run("presign-url", async () => {
+      return generate_presigned_get_url(session.audio_r2_key!, 3600);
+    });
+
+    // Transcribe via Deepgram
+    const result = await step.run("transcribe", async () => {
+      return transcribe_url(audio_url);
+    });
+
+    // Extract user-only speech (speaker 0 = user)
+    const user_transcript = user_speech_only(result);
+
+    // Store transcript JSON to R2
+    const transcript_r2_key = `transcripts/${user_id}/${session_id}.json`;
+    await step.run("store-transcript", async () => {
+      await upload_json(transcript_r2_key, {
+        full: result,
+        text: user_transcript,
+        stored_at: new Date().toISOString(),
+      });
+    });
+
+    // Update session record
+    await step.run("update-session", async () => {
+      await supabase
+        .from("sessions")
+        .update({
+          transcript_r2_key,
+          analysis_status: "pending", // reset so compact-identity picks it up
+          duration_seconds: Math.round(result.duration_seconds),
+        })
+        .eq("id", session_id);
+    });
+
+    // Fire next job
+    await step.sendEvent("trigger-analysis", {
+      name: "session/transcribed",
+      data: { user_id, session_id, transcript_r2_key },
+    });
+
+    return { session_id, duration_seconds: result.duration_seconds };
+  }
+);

package/src/lib/anthropic.ts

@@ -0,0 +1,37 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { config } from "./config.js";
+
+export const anthropic = new Anthropic({
+  apiKey: config.anthropic.api_key,
+});
+
+// Strip markdown code fences from LLM output and return raw JSON string
+export function extract_json(raw: string): string {
+  const fence = raw.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (fence) return fence[1].trim();
+  // Try to find first { or [ and last } or ]
+  const start = raw.search(/[{[]/);
+  const end = Math.max(raw.lastIndexOf("}"), raw.lastIndexOf("]"));
+  if (start !== -1 && end !== -1 && end > start) return raw.slice(start, end + 1);
+  return raw.trim();
+}
+
+// Thin wrapper — returns text content from a single-turn message
+export async function complete(
+  model: "conversation" | "analysis" | "matching",
+  system: string,
+  user: string,
+  max_tokens?: number
+): Promise<string> {
+  const default_tokens = model === "analysis" ? 8192 : 4096;
+  const response = await anthropic.messages.create({
+    model: config.anthropic.models[model],
+    max_tokens: max_tokens ?? default_tokens,
+    system,
+    messages: [{ role: "user", content: user }],
+  });
+
+  const block = response.content[0];
+  if (block.type !== "text") throw new Error("Unexpected non-text response");
+  return block.text;
+}

package/src/lib/config.ts

@@ -0,0 +1,81 @@
+import "dotenv/config";
+
+function require_env(key: string): string {
+  const val = process.env[key];
+  if (!val) throw new Error(`Missing required env var: ${key}`);
+  return val;
+}
+
+export const config = {
+  // Supabase
+  supabase: {
+    url: require_env("SUPABASE_URL"),
+    service_role_key: require_env("SUPABASE_SERVICE_ROLE_KEY"),
+  },
+
+  // Twilio
+  twilio: {
+    account_sid: require_env("TWILIO_ACCOUNT_SID"),
+    auth_token: require_env("TWILIO_AUTH_TOKEN"),
+    verify_service_sid: require_env("TWILIO_VERIFY_SERVICE_SID"),
+    // Phone numbers per brand
+    numbers: {
+      "meet-the-one": require_env("TWILIO_NUMBER_FLAGSHIP"),
+      casual: process.env["TWILIO_NUMBER_CASUAL"] ?? "",
+      kink: process.env["TWILIO_NUMBER_KINK"] ?? "",
+      adventure: process.env["TWILIO_NUMBER_ADVENTURE"] ?? "",
+      "open-poly": process.env["TWILIO_NUMBER_OPEN_POLY"] ?? "",
+    },
+  },
+
+  // Vapi (voice AI — v0.1)
+  vapi: {
+    api_key: require_env("VAPI_API_KEY"),
+    intake_assistant_id: require_env("VAPI_INTAKE_ASSISTANT_ID"),
+    consent_assistant_id: require_env("VAPI_CONSENT_ASSISTANT_ID"),
+  },
+
+  // Anthropic
+  anthropic: {
+    api_key: require_env("ANTHROPIC_API_KEY"),
+    models: {
+      conversation: "claude-sonnet-4-6",
+      analysis: "claude-opus-4-6",
+      matching: "claude-sonnet-4-6",
+    },
+  },
+
+  // OpenAI (embeddings)
+  openai: {
+    api_key: require_env("OPENAI_API_KEY"),
+    embedding_model: "text-embedding-3-large",
+    embedding_dimensions: 1536, // truncated — pgvector local limit is 2000
+  },
+
+  // Deepgram (transcription)
+  deepgram: {
+    api_key: require_env("DEEPGRAM_API_KEY"),
+    model: "nova-2",
+  },
+
+  // Cloudflare R2 (audio/transcript storage)
+  r2: {
+    account_id: require_env("CLOUDFLARE_ACCOUNT_ID"),
+    access_key_id: require_env("R2_ACCESS_KEY_ID"),
+    secret_access_key: require_env("R2_SECRET_ACCESS_KEY"),
+    bucket: require_env("R2_BUCKET_NAME"),
+    endpoint: `https://${require_env("CLOUDFLARE_ACCOUNT_ID")}.r2.cloudflarestorage.com`,
+  },
+
+  // Inngest
+  inngest: {
+    event_key: require_env("INNGEST_EVENT_KEY"),
+    signing_key: require_env("INNGEST_SIGNING_KEY"),
+  },
+
+  // App
+  app: {
+    url: process.env["APP_URL"] ?? "http://localhost:3000",
+    port: parseInt(process.env["PORT"] ?? "3000", 10),
+  },
+} as const;

package/src/lib/deepgram.ts

@@ -0,0 +1,57 @@
+import { createClient } from "@deepgram/sdk";
+import { config } from "./config.js";
+
+export const deepgram = createClient(config.deepgram.api_key);
+
+export interface TranscriptResult {
+  transcript: string; // full text
+  words: Array<{
+    word: string;
+    start: number;
+    end: number;
+    confidence: number;
+    speaker: number;
+  }>;
+  duration_seconds: number;
+}
+
+// Transcribe audio from a URL (e.g. presigned R2 URL)
+export async function transcribe_url(
+  audio_url: string
+): Promise<TranscriptResult> {
+  const { result, error } = await deepgram.listen.prerecorded.transcribeUrl(
+    { url: audio_url },
+    {
+      model: config.deepgram.model,
+      diarize: true,         // speaker separation
+      punctuate: true,
+      utterances: true,
+      smart_format: true,
+    }
+  );
+
+  if (error) throw new Error(`Deepgram error: ${error.message}`);
+  if (!result) throw new Error("No result from Deepgram");
+
+  const channel = result.results.channels[0].alternatives[0];
+
+  return {
+    transcript: channel.transcript,
+    words: (channel.words ?? []).map((w) => ({
+      word: w.word,
+      start: w.start,
+      end: w.end,
+      confidence: w.confidence,
+      speaker: w.speaker ?? 0,
+    })),
+    duration_seconds: result.metadata.duration,
+  };
+}
+
+// Extract only user speech (speaker 1) from transcript words
+export function user_speech_only(result: TranscriptResult): string {
+  return result.words
+    .filter((w) => w.speaker === 1)
+    .map((w) => w.word)
+    .join(" ");
+}

package/src/lib/inngest.ts

@@ -0,0 +1,33 @@
+import { Inngest } from "inngest";
+import { config } from "./config.js";
+
+export const inngest = new Inngest({
+  id: "meet-the-one",
+  eventKey: config.inngest.event_key,
+});
+
+// ─── Event type definitions ───────────────────────────────────────────────────
+
+export type Events = {
+  "session/completed": {
+    data: { user_id: string; session_id: string };
+  };
+  "session/transcribed": {
+    data: { user_id: string; session_id: string; transcript_r2_key: string };
+  };
+  "identity/updated": {
+    data: { user_id: string };
+  };
+  "match/confirmed": {
+    data: { match_id: string };
+  };
+  "match/both-accepted": {
+    data: { match_id: string };
+  };
+  "identity/reanalyze": {
+    data: { user_id: string };
+  };
+  "identity/export": {
+    data: { user_id: string };
+  };
+};

package/src/lib/openai.ts

@@ -0,0 +1,14 @@
+import OpenAI from "openai";
+import { config } from "./config.js";
+
+export const openai = new OpenAI({ apiKey: config.openai.api_key });
+
+// Generate embedding vector for a text string
+export async function embed(text: string): Promise<number[]> {
+  const response = await openai.embeddings.create({
+    model: config.openai.embedding_model,
+    input: text,
+    dimensions: config.openai.embedding_dimensions,
+  });
+  return response.data[0].embedding;
+}